精华内容
下载资源
问答
  • 随机森林标准手写数据分类 介绍 随机森林,指的是利用多棵树对样本进行训练并预测的一种分类器,将许多棵决策树整合成森林,并合起来用来预测最终结果,可以用来做分类、回归等问题。大多数情况下效果远要比SVM...

    随机森林对标准手写数据集分类

    介绍

    随机森林,指的是利用多棵树对样本进行训练并预测的一种分类器,将许多棵决策树整合成森林,并合起来用来预测最终结果,可以用来做分类、回归等问题。大多数情况下效果远要比SVM,log回归,KNN等算法效果好。

    随机森林的构建过程

    1.从原始训练集中随机有放回采样选出m个样本,共进行N次采样,生成N个训练集
    2.对于N个训练集,我们分别训练N个决策树模型
    3.对于单个决策树模型,假设训练样本特征的个数为n,那么每次分裂时根据信息增益/信息增益比/基尼指数选择最好的特征进行分裂
    4.每棵树都一直这样分裂下去,直到该节点的所有训练样例都属于同一类。在决策树的分裂过程中不需要剪枝
    5.将生成的多棵决策树组成随机森林。对于分类问题,按多棵树分类器投票决定最终分类结果,对于回归问题,由多棵树预测值的均值决定最终预测结果

    优点、缺点

    具有极高的准确率
    随机性的引入,使得随机森林不容易过拟合
    随机性的引入,使得随机森林有很好的抗噪声能力
    能处理很高维度的数据,并且不用做特征选择
    既能处理离散型数据,也能处理连续型数据,数据集无需规范化
    训练速度快,可以得到变量重要性排序
    容易实现并行化
    当随机森林中的决策树个数很多时,训练时需要的空间和时间会较大
    随机森林模型还有许多不好解释的地方,有点算个黑盒模型

    from sklearn.ensemble import RandomForestClassifier
    data=[[0,0,0],[1,1,1],[2,2,2],[1,1,1],[2,2,2],[3,3,3],[1,1,1],[4,4,4]]
    target=[0,1,2,1,2,3,1,4]
    rf = RandomForestClassifier()
    rf.fit(data,target)
    RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
                max_depth=None, max_features='auto', max_leaf_nodes=None,
                min_samples_leaf=1, min_samples_split=2,
                min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,
                oob_score=False, random_state=None, verbose=0,
                warm_start=False)
    print(rf.predict_proba([[1,1,1]]))
    #[[ 0.  1.  0.  0.  0.]]
    #输出是5个数,因为target有5个值
    
    import matplotlib.pyplot as plt
    import matplotlib.pyplot
    import seaborn as sns
    from sklearn.metrics import confusion_matrix
    from sklearn.datasets import load_digits
    from sklearn.model_selection import train_test_split
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import metrics
    digits = load_digits()
    fig = plt.figure(figsize=(6,6))
    fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
    for i in range(64):
        ax = fig.add_subplot(8,8,i+1, xticks=[], yticks=[])
        ax.imshow(digits.images[i], cmap=plt.cm.binary, interpolation='nearest')
        ax.text(0,7,str(digits.target[i]))
    x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, random_state=0)
    model = RandomForestClassifier(n_estimators=1000)
    model.fit(x_train, y_train)
    ypre = model.predict(x_test)
    print(metrics.classification_report(ypre, y_test))
    mat = confusion_matrix(y_test, ypre)
    sns.heatmap(mat.T, square=True, annot=True, fmt='d', cbar=False)
    plt.xlabel('true label')
    plt.ylabel('predicted label')
    matplotlib.pyplot.show()
    

    结果截图
    手写数据集的部分样本和热力图

    展开全文
  • 2019独角兽企业重金招聘Python工程师标准>>> ...

    MLlib是Spark的机器学习(ML)库,旨在简化机器学习的工程实践工作,并方便扩展到更大规模。

    MLlib由一些通用的学习算法和工具组成,包括分类、回归、聚类、协同过滤、降维等,同时还包括底层的优化原语和高层的管道API。

    MLllib目前分为两个代码包:spark.mllib 包含基于RDD的原始算法API。

    spark.ml ,提供了基于DataFrames高层次的API,可以用来构建机器学习管道,FEA-spk技术的机器学习就是基于spark.ml 包。

    spark.ml 包,是基于DataFrame的,未来将成为Spark机器学习的主要API。它可以在分布式集群上进行大规模的机器学习模型训练,并且可以对数据进行可视化。

    一、随机森林分类算法的介绍

    随机森林顾名思义,是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入时,就让森林中的每一棵决策树分别进行一下判断,看看这个样本应该属于哪一类(对应分类算法),然后看看哪一类被选择最多,就预测这个样本为那一类。

    使用Spark MLlib随机森林算法存在不足,需要改进!

    具体来讲,使用Spark MLlib进行模型的训练,需要进行大量的数据转化,列聚合为向量等。非常麻烦,并且不能做数据的可视化。

    而FEA-spk技术可以很好的解决这些问题。对模型进行训练只需要一句命令就行了,并且可以对结果数据进行可视化展示。

    二、Iris 数据分类训练案例

    下面列举一个用随机森林分类算法进行Iris 数据分类的例子。

    1. 数据准备

    原始的数据以及相应的说明可以到https://pan.baidu.com/s/1c2d0hpA下载。 我在这基础之上,增加了header信息。 

    这里将下载好的数据放到hdfs上面进行读取。

    2. Iris 数据进行训练的具体步骤

    (1)要使用FEA-spk技术,首先要创建一个spk的连接,所有的操作都是以它为上下文进行的。在fea界面运行以下命令

    134646_dV4C_3115904.png

    (2)加载数据,数据在hdfs上面,数据的格式为csv文件格式,目录为/data/iris_data.txt

    134657_6nmF_3115904.png

    134707_PLF4_3115904.png

    (3)使用ML_si方法将字符型的label变成index       

    134715_4crK_3115904.png

    134722_GohY_3115904.png

    (4)将特征列的类型转化为double类型,因为spark.ml只支持double类型,使用 ML_double方法

    111047_ApIv_3115904.gif134731_V9dE_3115904.png

    (5)使用随机森林模型进行训练

    在训练RandomForest模型的时候,我们需要设置好几个参数:

    · maxBins

    最大装箱数,为了近似统计变量,比如变量有100个值,我只分成10段去做统计,默认值是32;

    · numTrees

    森林里有几棵树,默认值是20;

    · minInstancesPerNode

    每个节点最少实例,默认值是1;

    · minInfoGain

    最小信息增益,默认值是0.0;

    · maxDepth

    最大树深度,默认值是5;

    · maxMemoryInMB

    最大内存MB单位,这个值越大,一次处理的节点划分就越多,默认值是256;

    · cacheNodeIds

    是否缓存节点id,缓存可以加速深层树的训练,默认值是False;

    · checkpointInterval

    检查点间隔,就是多少次迭代固化一次,默认值是10;

    · impurity

    随机森林有三种方式,entropy,gini,variance,回归肯定就是variance,默认值是gini;

    · seed

    采样种子,种子不变,采样结果不变,默认值None;

    · featureSubsetStrategy

    auto: 默认参数。让算法自己决定,每颗树使用几条数据。

    使用的参数如下图所示

    111047_WKKF_3115904.gif134743_lPjp_3115904.png

    (6)对训练好的模型进行打分

    111047_M7sN_3115904.gif134750_mCiC_3115904.png

    134757_MU6k_3115904.png

    可以看到准确率达到了97%

    (7)将训练好的模型保存到hdfs上面,以供下次使用

    134809_KW5t_3115904.png

    134817_4liA_3115904.png

    这个非常实用,对于模型比较大的情况下,利用HDFS的分布式结构就可以提高加载性能。

    (8)将hdfs上面保存的模型加载进来

    134826_dW0V_3115904.png

    (9)对加载后的模型做预测

    134834_R2eA_3115904.png

    其中prediction列就是预测的结果

    以上就是使用FEA-spk技术进行机器学习的步骤,它非常适合数据分析处理大规模的数据,简单、强大、可视化,不懂Java\Python同样可以玩转Spark!

    转载于:https://my.oschina.net/u/3115904/blog/1505716

    展开全文
  • Python机器学习/数据挖掘项目实战 泰坦尼克号Titanic生存预测 Kaggle入门比赛Titanic : Machine Learning from Disaster 随机森林分类

    Titanic : Machine Learning from Disaster

    链接:GitHub源代码

    Question

    • 要求你建立一个预测模型来回答这个问题:“什么样的人更有可能生存?”使用乘客数据(如姓名、年龄、性别、社会经济阶层等)。

    一、导入数据包和数据集

    import pandas as pd
    from pandas import Series, DataFrame
    import numpy as np
    from matplotlib import pyplot as plt
    import seaborn as sns
    
    • 重点:在kaggle notebook上时,应该把pd.read_csv("./kaggle/input/titanic/train.csv")引号中第一个'.'去掉
    • 读入训练集和测试及都需要
    train = pd.read_csv("./kaggle/input/titanic/train.csv")
    test = pd.read_csv("./kaggle/input/titanic/test.csv")
    allData = pd.concat([train, test], ignore_index=True)
    # dataNum = train.shape[0]
    # featureNum = train.shape[1]
    train.info()
    

    二、数据总览

    概况

    • 输入train.info()回车可以查看数据集整体信息
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 12 columns):
    PassengerId    891 non-null int64
    Survived       891 non-null int64
    Pclass         891 non-null int64
    Name           891 non-null object
    Sex            891 non-null object
    Age            714 non-null float64
    SibSp          891 non-null int64
    Parch          891 non-null int64
    Ticket         891 non-null object
    Fare           891 non-null float64
    Cabin          204 non-null object
    Embarked       889 non-null object
    dtypes: float64(2), int64(5), object(5)
    memory usage: 83.6+ KB
    
    • 输入train.head()可以查看数据样例

    特征

    VariableDefinitionKey
    survivalSurvival0 = No, 1 = Yes
    pclassTicket class(客舱等级)1 = 1st, 2 = 2nd, 3 = 3rd
    sexSex
    AgeAge in years
    sibsp# of siblings / spouses aboard the Titanic(旁系亲属)
    parch# of parents / children aboard the Titanic(直系亲属)
    ticketTicket number
    farePassenger fare
    cabinCabin number(客舱编号)
    embarkedPort of Embarkation(上船港口编号)C = Cherbourg, Q = Queenstown, S = Southampton

    三、可视化数据分析

    性别特征Sex

    • 女性生存率远高于男性
    # Sex
    sns.countplot('Sex', hue='Survived', data=train)
    plt.show()
    

    等级特征Pclass

    • 乘客等级越高,生存率越高
    # Pclass
    sns.barplot(x='Pclass', y="Survived", data=train)
    plt.show()
    

    家庭成员数量特征

    • FamilySize=Parch+SibSp

    • 家庭成员数量适中,生存率高
    # FamilySize = SibSp + Parch + 1
    allData['FamilySize'] = allData['SibSp'] + allData['Parch'] + 1
    sns.barplot(x='FamilySize', y='Survived', data=allData)
    plt.show()
    

    上船港口特征Embarked

    • 上船港口不同,生存率不同
    # Embarked
    sns.countplot('Embarked', hue='Survived', data=train)
    plt.show()
    

    年龄特征Age

    • 年龄小或者正值壮年生存率高
    # Age
    sns.stripplot(x="Survived", y="Age", data=train, jitter=True)
    plt.show()
    

    • 年龄生存密度
    facet = sns.FacetGrid(train, hue="Survived",aspect=2)
    facet.map(sns.kdeplot,'Age',shade= True)
    facet.set(xlim=(0, train['Age'].max()))
    facet.add_legend()
    plt.xlabel('Age') 
    plt.ylabel('density') 
    plt.show()
    

    • 儿童相对于全年龄段有特殊的生存率
    • 作者将10及以下视为儿童,设置单独标签

    费用特征Fare

    • 费用越高,生存率越高
    # Fare
    sns.stripplot(x="Survived", y="Fare", data=train, jitter=True)
    plt.show()
    

    姓名特征Name

    头衔特征Title

    • 头衔由姓名的前置称谓进行分类
    # Name
    allData['Title'] = allData['Name'].apply(lambda x:x.split(',')[1].split('.')[0].strip())
    pd.crosstab(allData['Title'], allData['Sex'])
    
    • 统计分析
    TitleClassification = {'Officer':['Capt', 'Col', 'Major', 'Dr', 'Rev'],
                           'Royalty':['Don', 'Sir', 'the Countess', 'Dona', 'Lady'],
                           'Mrs':['Mme', 'Ms', 'Mrs'],
                           'Miss':['Mlle', 'Miss'],
                           'Mr':['Mr'],
                           'Master':['Master','Jonkheer']}
    for title in TitleClassification.keys():
        cnt = 0
        for name in TitleClassification[title]:
            cnt += allData.groupby(['Title']).size()[name]
        print (title,':',cnt)
    
    • 设置标签
    TitleClassification = {'Officer':['Capt', 'Col', 'Major', 'Dr', 'Rev'],
                           'Royalty':['Don', 'Sir', 'the Countess', 'Dona', 'Lady'],
                           'Mrs':['Mme', 'Ms', 'Mrs'],
                           'Miss':['Mlle', 'Miss'],
                           'Mr':['Mr'],
                           'Master':['Master','Jonkheer']}
    TitleMap = {}
    for title in TitleClassification.keys():
        TitleMap.update(dict.fromkeys(TitleClassification[title], title))
    allData['Title'] = allData['Title'].map(TitleMap)
    
    • 头衔不同,生存率不同
    sns.barplot(x="Title", y="Survived", data=allData)
    plt.show()
    

    票号特征Ticket

    • 有一定连续座位(存在票号相同的乘客)生存率高
    #Ticket
    TicketCnt = allData.groupby(['Ticket']).size()
    allData['SameTicketNum'] = allData['Ticket'].apply(lambda x:TicketCnt[x])
    sns.barplot(x='SameTicketNum', y='Survived', data=allData)
    plt.show()
    # allData['SameTicketNum']
    

    二维/多维分析

    • 可以将任意两个/多个数据进行分析

    二维分析之Pclass & Age

    # Pclass & Age
    sns.violinplot("Pclass", "Age", hue="Survived", data=train, split=True)
    plt.show()
    

    二维分析之Age & Sex

    # Age & Sex
    sns.swarmplot(x='Age', y="Sex", data=train, hue='Survived')
    plt.show()
    

    四、数据清洗 & 异常处理

    离散型数据

    有可用标签 --> One-Hot编码

    • Sex & Pclass & Embarked 都有已经设置好的标签(int或float或string等),可以直接进行get_dummies,拆分成多维向量,增加特征维度
    • 其中,Embarked存在一定缺失值,通过对整体的分析,填充上估计值
    # Sex
    allData = allData.join(pd.get_dummies(allData['Sex'], prefix="Sex"))
    # Pclass
    allData = allData.join(pd.get_dummies(allData['Pclass'], prefix="Pclass"))
    # Embarked
    allData[allData['Embarked'].isnull()] # 查看缺失值
    allData.groupby(by=['Pclass','Embarked']).Fare.mean() # Pclass=1, Embark=C, 中位数=76
    allData['Embarked'] = allData['Embarked'].fillna('C')
    allData = allData.join(pd.get_dummies(allData['Embarked'], prefix="Embarked"))
    

    无可用标签 --> 设计标签 --> One-Hot

    • FamilySize & Name & Ticket需要对整体数据统一处理,再进行标记
    # FamilySize
    def FamilyLabel(s):
        if (s == 4):
            return 4
        elif (s == 2 or s == 3):
            return 3
        elif (s == 1 or s == 7):
            return 2
        elif (s == 5 or s == 6):
            return 1
        elif (s < 1 or s > 7):
            return 0
    allData['FamilyLabel'] = allData['FamilySize'].apply(FamilyLabel)
    allData = allData.join(pd.get_dummies(allData['FamilyLabel'], prefix="Fam"))
    
    # Name
    TitleLabelMap = {'Mr':1.0,
                     'Mrs':5.0,
                     'Miss':4.5,
                     'Master':2.5,
                     'Royalty':3.5,
                     'Officer':2.0}
    def TitleLabel(s):
        return TitleLabelMap[s]
    # allData['TitleLabel'] = allData['Title'].apply(TitleLabel)
    allData = allData.join(pd.get_dummies(allData['Title'], prefix="Title"))
    
    # Ticket
    def TicketLabel(s):
        if (s == 3 or s == 4):
            return 3
        elif (s == 2 or s == 8):
            return 2
        elif (s == 1 or s == 5 or s == 6 or s ==7):
            return 1
        elif (s < 1 or s > 8):
            return 0
    allData['TicketLabel'] = allData['SameTicketNum'].apply(TicketLabel)
    allData = allData.join(pd.get_dummies(allData['TicketLabel'], prefix="TicNum"))
    

    连续型数据

    Age & Fare

    • 进行标准化,缩小数据范围,加速梯度下降
    # Age
    allData['Child'] = allData['Age'].apply(lambda x:1 if x <= 10 else 0) # 儿童标签
    allData['Age'] = (allData['Age']-allData['Age'].mean())/allData['Age'].std() # 标准化
    allData['Age'].fillna(value=0, inplace=True) # 填充缺失值
    # Fare
    allData['Fare'] = allData['Fare'].fillna(25) # 填充缺失值
    allData[allData['Survived'].notnull()]['Fare'] = allData[allData['Survived'].notnull()]['Fare'].apply(lambda x:300.0 if x>500 else x)
    allData['Fare'] = allData['Fare'].apply(lambda x:(x-allData['Fare'].mean())/allData['Fare'].std())
    

    清除无用特征

    • 清除无用特征,降低算法复杂度
    # 清除无用特征
    allData.drop(['Cabin', 'PassengerId', 'Ticket', 'Name', 'Title', 'Sex', 'SibSp', 'Parch', 'FamilySize', 'Embarked', 'Pclass', 'Title', 'FamilyLabel', 'SameTicketNum', 'TicketLabel'], axis=1, inplace=True)
    

    重新分割训练集/测试集

    • 一开始,为了处理方便,作者将训练集和测试集合并,现在根据Survived是否缺失来讲训练集和测试集分开
    # 重新分割数据集
    train_data = allData[allData['Survived'].notnull()]
    test_data  = allData[allData['Survived'].isnull()]
    test_data = test_data.reset_index(drop=True)
    
    xTrain = train_data.drop(['Survived'], axis=1)
    yTrain = train_data['Survived']
    xTest  = test_data.drop( ['Survived'], axis=1)
    

    特征相关性分析

    • 该步骤用于筛选特征后向程序员反馈,特征是否有效、是否重叠
    • 若有问题,可以修改之前的特征方案
    # 特征间相关性分析
    Correlation = pd.DataFrame(allData[allData.columns.to_list()])
    colormap = plt.cm.viridis
    plt.figure(figsize=(24,22))
    sns.heatmap(Correlation.astype(float).corr(), linewidths=0.1, vmax=1.0, cmap=colormap, linecolor='white', annot=True, square=True)
    plt.show()
    

    五、模型建立 & 参数优化

    导入模型包

    from sklearn.pipeline import Pipeline
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import GridSearchCV
    from sklearn.feature_selection import SelectKBest
    
    • 作者选择随机森林分类器

    网格搜索调试参数

    pipe = Pipeline([('select', SelectKBest(k=10)),
                     ('classify', RandomForestClassifier(random_state = 10, max_features = 'sqrt'))])
    param_test = {'classify__n_estimators':list(range(20,100,5)),
                  'classify__max_depth'   :list(range(3,10,1))}
    gsearch = GridSearchCV(estimator=pipe, param_grid=param_test, scoring='roc_auc', cv=10)
    gsearch.fit(xTrain, yTrain)
    print (gsearch.best_params_, gsearch.best_score_)
    
    • 运行时间较长,结束后出现结果:
    {'classify__max_depth': 6, 'classify__n_estimators': 70} 0.8790924679681529
    

    建立模型

    • 用以上参数进行输入模型
    • 训练
    rfc = RandomForestClassifier(n_estimators=70, max_depth=6, random_state=10, max_features='sqrt')
    rfc.fit(xTrain, yTrain)
    

    导出结果

    predictions = rfc.predict(xTest)
    output = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':predictions.astype('int64')})
    output.to_csv('my_submission.csv', index=False)
    

    六、提交评分

    附:完整代码

    • Jupiter Notebook导出为Python Script格式,需要ipynb格式请点击
    • GitHub源代码

    # To add a new cell, type '# %%'
    # To add a new markdown cell, type '# %% [markdown]'
    
    # %%
    import pandas as pd
    from pandas import Series, DataFrame
    import numpy as np
    from matplotlib import pyplot as plt
    import seaborn as sns
    
    # %% [markdown]
    # # Features
    # Variable | Definition | Key
    # :-:|:-:|:-:
    # survival | Survival | 0 = No, 1 = Yes
    # pclass | Ticket class(客舱等级) | 1 = 1st, 2 = 2nd, 3 = 3rd
    # sex | Sex
    # Age | Age in years
    # sibsp | # of siblings / spouses aboard the Titanic(旁系亲属)
    # parch | # of parents / children aboard the Titanic(直系亲属)
    # ticket | Ticket number
    # fare | Passenger fare
    # cabin | Cabin number(客舱编号)
    # embarked | Port of Embarkation(上船的港口编号) | C = Cherbourg, Q = Queenstown, S = Southampton
    
    # %%
    train = pd.read_csv("./kaggle/input/titanic/train.csv")
    test = pd.read_csv("./kaggle/input/titanic/test.csv")
    allData = pd.concat([train, test], ignore_index=True)
    # dataNum = train.shape[0]
    # featureNum = train.shape[1]
    train.head()
    
    
    # %%
    # Sex
    sns.countplot("Sex", hue="Survived", data=train)
    plt.show()
    
    
    # %%
    # Pclass
    sns.barplot(x="Pclass", y="Survived", data=train)
    plt.show()
    # Pclass & Age
    sns.violinplot("Pclass", "Age", hue="Survived", data=train, split=True)
    plt.show()
    
    
    # %%
    # FamilySize = SibSp + Parch + 1
    allData["FamilySize"] = allData["SibSp"] + allData["Parch"] + 1
    sns.barplot(x="FamilySize", y="Survived", data=allData)
    plt.show()
    
    
    # %%
    # Embarked
    sns.countplot("Embarked", hue="Survived", data=train)
    plt.show()
    
    
    # %%
    # Age
    sns.stripplot(x="Survived", y="Age", data=train, jitter=True)
    plt.show()
    facet = sns.FacetGrid(train, hue="Survived", aspect=2)
    facet.map(sns.kdeplot, "Age", shade=True)
    facet.set(xlim=(0, train["Age"].max()))
    facet.add_legend()
    plt.xlabel("Age")
    plt.ylabel("density")
    plt.show()
    # Age & Sex
    sns.swarmplot(x="Age", y="Sex", data=train, hue="Survived")
    plt.show()
    
    
    # %%
    # Fare
    sns.stripplot(x="Survived", y="Fare", data=train, jitter=True)
    plt.show()
    
    
    # %%
    # Name
    # allData['Title'] = allData['Name'].str.extract('([A-Za-z]+)\.', expand=False) # str.extract不知道在干嘛
    allData["Title"] = allData["Name"].apply(
        lambda x: x.split(",")[1].split(".")[0].strip()
    )
    # pd.crosstab(allData['Title'], allData['Sex'])
    TitleClassification = {
        "Officer": ["Capt", "Col", "Major", "Dr", "Rev"],
        "Royalty": ["Don", "Sir", "the Countess", "Dona", "Lady"],
        "Mrs": ["Mme", "Ms", "Mrs"],
        "Miss": ["Mlle", "Miss"],
        "Mr": ["Mr"],
        "Master": ["Master", "Jonkheer"],
    }
    TitleMap = {}
    for title in TitleClassification.keys():
        TitleMap.update(dict.fromkeys(TitleClassification[title], title))
        """
        # cnt = 0
        for name in TitleClassification[title]:
            cnt += allData.groupby(['Title']).size()[name]
        # print (title,':',cnt)
        """
    allData["Title"] = allData["Title"].map(TitleMap)
    sns.barplot(x="Title", y="Survived", data=allData)
    plt.show()
    
    
    # %%
    # Ticket
    TicketCnt = allData.groupby(["Ticket"]).size()
    allData["SameTicketNum"] = allData["Ticket"].apply(lambda x: TicketCnt[x])
    sns.barplot(x="SameTicketNum", y="Survived", data=allData)
    plt.show()
    # allData['SameTicketNum']
    
    # %% [markdown]
    # # 数据清洗
    # - Sex & Pclass & Embarked --> Ont-Hot
    # - Age & Fare --> Standardize
    # - FamilySize & Name & Ticket --> ints --> One-Hot
    
    # %%
    # Sex
    allData = allData.join(pd.get_dummies(allData["Sex"], prefix="Sex"))
    # Pclass
    allData = allData.join(pd.get_dummies(allData["Pclass"], prefix="Pclass"))
    # Embarked
    allData[allData["Embarked"].isnull()]  # 查看缺失值
    allData.groupby(by=["Pclass", "Embarked"]).Fare.mean()  # Pclass=1, Embark=C, 中位数=76
    allData["Embarked"] = allData["Embarked"].fillna("C")
    allData = allData.join(pd.get_dummies(allData["Embarked"], prefix="Embarked"))
    
    
    # %%
    # Age
    allData["Child"] = allData["Age"].apply(lambda x: 1 if x <= 10 else 0)  # 儿童标签
    allData["Age"] = (allData["Age"] - allData["Age"].mean()) / allData["Age"].std()  # 标准化
    allData["Age"].fillna(value=0, inplace=True)  # 填充缺失值
    # Fare
    allData["Fare"] = allData["Fare"].fillna(25)  # 填充缺失值
    allData[allData["Survived"].notnull()]["Fare"] = allData[allData["Survived"].notnull()][
        "Fare"
    ].apply(lambda x: 300.0 if x > 500 else x)
    allData["Fare"] = allData["Fare"].apply(
        lambda x: (x - allData["Fare"].mean()) / allData["Fare"].std()
    )
    
    
    # %%
    # FamilySize
    def FamilyLabel(s):
        if s == 4:
            return 4
        elif s == 2 or s == 3:
            return 3
        elif s == 1 or s == 7:
            return 2
        elif s == 5 or s == 6:
            return 1
        elif s < 1 or s > 7:
            return 0
    
    
    allData["FamilyLabel"] = allData["FamilySize"].apply(FamilyLabel)
    allData = allData.join(pd.get_dummies(allData["FamilyLabel"], prefix="Fam"))
    
    # Name
    TitleLabelMap = {
        "Mr": 1.0,
        "Mrs": 5.0,
        "Miss": 4.5,
        "Master": 2.5,
        "Royalty": 3.5,
        "Officer": 2.0,
    }
    
    
    def TitleLabel(s):
        return TitleLabelMap[s]
    
    
    # allData['TitleLabel'] = allData['Title'].apply(TitleLabel)
    allData = allData.join(pd.get_dummies(allData["Title"], prefix="Title"))
    
    # Ticket
    def TicketLabel(s):
        if s == 3 or s == 4:
            return 3
        elif s == 2 or s == 8:
            return 2
        elif s == 1 or s == 5 or s == 6 or s == 7:
            return 1
        elif s < 1 or s > 8:
            return 0
    
    
    allData["TicketLabel"] = allData["SameTicketNum"].apply(TicketLabel)
    allData = allData.join(pd.get_dummies(allData["TicketLabel"], prefix="TicNum"))
    
    
    # %%
    # 清除无用特征
    allData.drop(
        [
            "Cabin",
            "PassengerId",
            "Ticket",
            "Name",
            "Title",
            "Sex",
            "SibSp",
            "Parch",
            "FamilySize",
            "Embarked",
            "Pclass",
            "Title",
            "FamilyLabel",
            "SameTicketNum",
            "TicketLabel",
        ],
        axis=1,
        inplace=True,
    )
    
    # 重新分割数据集
    train_data = allData[allData["Survived"].notnull()]
    test_data = allData[allData["Survived"].isnull()]
    test_data = test_data.reset_index(drop=True)
    
    xTrain = train_data.drop(["Survived"], axis=1)
    yTrain = train_data["Survived"]
    xTest = test_data.drop(["Survived"], axis=1)
    
    # allData.columns.to_list()
    
    
    # %%
    # 特征间相关性分析
    Correlation = pd.DataFrame(allData[allData.columns.to_list()])
    colormap = plt.cm.viridis
    plt.figure(figsize=(24, 22))
    sns.heatmap(
        Correlation.astype(float).corr(),
        linewidths=0.1,
        vmax=1.0,
        cmap=colormap,
        linecolor="white",
        annot=True,
        square=True,
    )
    plt.show()
    
    # %% [markdown]
    # # 网格筛选随机森林参数
    # - n_estimator
    # - max_depth
    
    # %%
    from sklearn.pipeline import Pipeline
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import GridSearchCV
    from sklearn.feature_selection import SelectKBest
    
    
    # %%
    
    pipe = Pipeline(
        [
            ("select", SelectKBest(k=10)),
            ("classify", RandomForestClassifier(random_state=10, max_features="sqrt")),
        ]
    )
    param_test = {
        "classify__n_estimators": list(range(20, 100, 5)),
        "classify__max_depth": list(range(3, 10, 1)),
    }
    gsearch = GridSearchCV(estimator=pipe, param_grid=param_test, scoring="roc_auc", cv=10)
    gsearch.fit(xTrain, yTrain)
    print(gsearch.best_params_, gsearch.best_score_)
    
    
    # %%
    rfc = RandomForestClassifier(
        n_estimators=70, max_depth=6, random_state=10, max_features="sqrt"
    )
    rfc.fit(xTrain, yTrain)
    predictions = rfc.predict(xTest)
    
    output = pd.DataFrame(
        {"PassengerId": test["PassengerId"], "Survived": predictions.astype("int64")}
    )
    output.to_csv("my_submission.csv", index=False)
    

    链接:GitHub源代码

    展开全文
  • 使用决策树和随机森林数据分类

    千次阅读 2020-11-01 21:09:05
    文章目录前言一、使用决策树和随机森林数据分类二、代码拆分成训练数据和测试数据CART决策树分类检查准确率检查准确率三、总结 前言 在研究机器学习,发现了一些宝藏算法,写下来让自己记住,超有用!同时也想要...


    前言

    在研究机器学习,发现了一些宝藏算法,写下来让自己记住,超有用!同时也想要分享给大家,如果喜欢可以支持一下,谢谢。

    一、使用决策树和随机森林对数据分类

    使用决策树算法和随机森林算法对income_classification.csv的收入水平进行分类。训练集和测试集的比例是7:3,选取适当的特征列,使得针对测试样本的分类准确率在80%以上,比较2种分类方法的准确率。

    数据说明:

    特征列

    age:年龄,整数

    workclass:工作性质,字符串

    education:教育程度,字符串

    education_num:受教育年限,整数

    maritial_status:婚姻状况,字符串

    occupation:职业,字符串

    relationship:亲戚关系,字符串

    race:种族,字符串

    sex:性别,字符串

    capital_gain:资本收益,浮点数

    capital_loss:资本损失,浮点数

    hours_per_week:每周工作小时数,浮点数

    native_country:原籍,字符串

    分类标签列:income

    imcome > 50K

    Imcome ≤ 50K

      读入数据并显示数据的维度和前5行数据
    

    import pandas as pd

    import numpy as np

    对连续变量年龄进行离散化,并显示前5行数据离散化后的结果

    age_bins = [20, 30,40, 50, 60, 70]

    对属性是字符串的任意特征进行数字编号处理,显示前5行编码后的结果,每个特定的字符串用一个整数来表示,整数序列从0开始增长。

    from sklearn.preprocessing import LabelEncoder

    enc = LabelEncoder()

    对预处理后的数据用决策树算法和随机森林算法分类

    代码思路:

    1. 选择合适的若干特征字段

    2. 按7:3划分训练集和样本集

    3. 使用训练集训练一个决策树分类器

    4. 使用测试集计算决策树分类器的分类准确率

    5. 使用训练集训练一个随机森林分类器

    6. 使用测试集计算随机森林分类器的分类准确率

    fromsklearn.ensemble import RandomForestClassifier

    from sklearn importtree

    fromsklearn.preprocessing import LabelEncoder

    fromsklearn.feature_extraction import DictVectorizer

    accuracy_random =clf_random.score(xTest, yTest)

    二、代码

    import numpy as np
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import tree

    print(‘1.载入数据…’)
    data = []
    labels = []
    with open(“income_classification.csv”) as ifile:
    for line in ifile:
    # data需要是字典形式,因为之后需要使用DictVectorizer()修改字符串数据类型,以便符合DecisionTreeClassifier()
    rowDict = {}
    tokens = line.strip().split(’,’)
    rowDict[‘age’] = tokens[0]
    rowDict[‘workclass’] = tokens[1]
    rowDict[‘education_num’] = tokens[2]
    rowDict[‘maritial_status’] = tokens[3]
    rowDict[‘occupation’] = tokens[4]
    rowDict[‘relationship’] = tokens[5]
    rowDict[‘race’] = tokens[6]
    rowDict[‘sex’] = tokens[7]
    rowDict[‘capital_gain’] = tokens[8]
    rowDict[‘capital_loss’] = tokens[9]
    rowDict[‘hours_per_week’] = tokens[10]
    rowDict[‘native_country’] = tokens[11]
    rowDict[‘income’] = tokens[12]
    data.append(rowDict)
    labels.append(tokens[-1])

    print(‘2. 构造数据和标签…’)
    x = np.array(data)
    labels = np.array(labels)
    y = np.zeros(labels.shape) # 初始label全为0

    y[labels == ‘<=50K’] = 0 # 当label等于这三种属性的话,设置为1。
    y[labels == ‘>50K’] = 1

    print(‘3.转换字符串数据类型…’)
    vec = DictVectorizer() # 转换字符串数据类型
    dx = vec.fit_transform(x).toarray()

    print(‘4.拆分训练数据和测试数据…’)
    print(‘训练集和验证集比例7:3’)

    拆分成训练数据和测试数据

    ratio = 0.7
    xTrain = []
    yTrain = []
    xTest = []
    yTest = []
    features = xTrain, xTest
    labels = yTrain, yTest
    for i in range(len(dx)):
    dataSetIndex = 0 if np.random.random() < ratio else 1
    features[dataSetIndex].append(dx[i])
    labels[dataSetIndex].append(y[i])

    CART决策树分类

    print(‘5.CART决策树分类…’)
    clf_cart = tree.DecisionTreeClassifier(criterion = ‘entropy’) # CART算法,使用entropy作为标准;默认是是用gini作为标准
    clf_cart.fit(xTrain, yTrain)

    检查准确率

    accuracy_cart = clf_cart.score(xTest, yTest)
    print(‘CART树分类准确率:’,accuracy_cart)

    print(‘6.随机森林分类…’)
    clf_random = RandomForestClassifier()
    clf_random.fit(xTrain, yTrain)

    检查准确率

    accuracy_random = clf_random.score(xTest, yTest)
    print(‘随机森林分类准确率:’, accuracy_random)


    以上代码全部复制进python环境即可运行,亲测有效

    三、总结

    python库很强大,短短几句话就完事了。
    但是如果你不知道有这几句话,你确实得找很久
    希望我能帮你省些时间,喜欢的可以支持一下,谢谢啦~

    展开全文
  • 采用随机森林分类模型(RandomForestClassifier)再次训练上述鸢尾花数据集,具体要求如下: 1、使用pandas库再次读取数据集,得到相应矩阵,并进项相应的数据预处理:包括数据标准化与鸢尾花类别编码等。 2、采用...
  • 机器学习 随机森林分类Tree-based algorithms are popular machine learning methods used to solve supervised learning problems. These algorithms are flexible and can solve any kind of problem at hand ...
  • 实践的同样是分类算法模型,随机森林模型可以简单理解为集成的决策树模型,实质上随机森林模型的设计思想也的确如此,它采用了一种投票的思想来完成了模型最终的决策,将多个弱分类器模型进行集成,来达到提升基分类...
  • 阅读报告-A random forests...4.观察到虽然BRF显著改善了少数类的分类,而且优于普通的随机森林算法,在标准不平衡数据集上其性能也与RFQ算法大致相同。但在高复杂性,高不平衡性和高维度的不平衡数据集中处于劣势。
  • sklearn 随机森林分类iris花

    千次阅读 2019-06-12 15:19:54
    #!/usr/bin/env python # coding: utf-8 # ### 导入随面森林的...from sklearn.ensemble import RandomForestClassifier # 导入随机森林的包 # from sklearn.model_selection import train_test_split # 这个用于...
  • “实践是检验真理的唯一标准。”“复现是学习生信的最好办法。”2021.4.12_1DOI: 10.1016/j.cell.2020.05.032这篇2020年发表在cell上关于新冠的组学...
  • 采用了随机森林和支持向量机的方法进行实验。对原始数据进行了异常值处理和属性数字的预处理操作,得到实验数据。实验1对数据进行十折交叉验证取十次结果平均值作为最终结果,度量方法为准确率,分别在两种模型上...
  • 并行化随机森林实现分析

    千次阅读 2016-03-03 21:07:58
    题目大意、训练数据与测试数据 非线性分类问题。数据一共有26种分类(1—26)。...随机森林是由美国科学家Leo Breiman将其在 1996年提出的Bagging集成学习理论与Ho在1998年提出的随机子空间方法相结合,于2
  • 数据分析(三)实战——分类模型(随机森林与 AdaBoost )基本信息数据预处理观察数据集特点数据集划分特征选择异常值检测离散化标准化模型训练分类器选择评估指标选择训练过程默认参数训练结果参数调整最优训练结果...
  • python随机森林回归数据实战

    千次阅读 多人点赞 2020-11-12 11:51:53
    重点代码2.1特征集和标签集获取2.2数据集划分2.3随机森林模型训练2.4预测结果可视2.5 特征重要性选择及可视3.完整代码总结 前言 我为什么写这篇博客? 答:记录一下自己对于sklearn库的学习过程以及学习方法,...
  • #实例一个随机森林分类器对象 指定包含5棵决策树,最大叶子节点数为16,用5个线程进行训练 rnd_clf = RandomForestClassifier(n_estimators=15, max_leaf_nodes=20, n_jobs=5) rnd_clf.fit(X_train, y_train) y_...
  • 7 数据预处理-数据标准化

    千次阅读 2017-07-01 11:10:07
    数据预处理-数据标准化数据预处理-数据标准化 正规化 Normalization 例子1 - 数据标准化 例子2 - 数据标准化对机器学习成效的影响 正规化 Normalization这个文章知识讲解了入门的数据预处理,更多的归一化方法请看:...
  • 随机森林

    千次阅读 2017-07-08 21:29:04
    随机森林原理
  • 随机森林特征筛选 关于的特征的筛选,可以利用皮尔逊系数,如果是分类的变量的话可以用卡方检验,这些都是再用具体算法跑之前所做的数据处理。我们还可以用一个算法先跑,然后看数据属性的特征,也就是选择主要的...
  • 使用随机森林(Random Forest)进行特征筛选并可视 随机森林可以理解为Cart树森林,它是由多个Cart树分类器构成的集成学习模式。其中每个Cart树可以理解为一个议员,它从样本集里面随机有放回的抽取一部分进行...
  • 摘要 考虑到现有的点云分类算法在提取依赖结构的特征参数时面临邻域...使用随机森林的特征选择算法对分类特征进行优化,然后进行点云分类 实验表明,归一高度特征在点云分类中所起作用最大 归一高度 基于布料...
  • 研究大纲 介绍数据集和研究的目标 探索数据集 可视 使用Chi-Square独立检验、Cramer's V检验和GoodmanKruskal tau值对数据进行探索 ... 预测模型,Logisitic... 随机森林模型 用RandomForest和Logisit..
  • 1、对数据进行处理并训练评估模型 from sklearn.model_selection import train_test_split, cross_val_score, KFold, GridSearchCV import pandas as pd import numpy as np from sklearn.ensemble import ...
  • (一)数据标准化的方法: (1)离差标准化(最大最小值标准化) (2)标准差标准化、 (3)归一化标准化 ...
  • 一、数据标准化(归一化) 首先,数据标准化处理主要包括数据同趋化处理(中心化处理)和无量纲化处理。同趋化处理主要解决不同性质数据问题,对不同性质指标直接加总不能正确反映不同作用力的综合结果,须先考虑...
  • 使用sklearn对数据进行标准化/正则化

    千次阅读 2019-05-17 15:38:47
    也叫离差标准化,是对原始数据的线性变换,使结果落到[0,1]区间,转换函数如下: x∗=x−minmax−minx^*= \frac{x-min} {max-min}x∗=max−minx−min​ 其中max为样本数据的最大值,min为样本数据的最小值。这种方法...
  • 随机森林分类建模

    千次阅读 2015-12-15 15:13:56
    用了逻辑回归和随机森林,显然后者要好很多,因为维度一千多个,而且逻辑回归要涉及到更详细的特征处理,第一部分是r代码,第二部分是py 一 r code rm(list=ls()) library(caret) train_x train_y train rep for (i...
  • 随机森林实例:利用基于CART算法的随机森林(Random Forest)树分类方法对于红酒质量进行预测1、引言2、理论基础2.1 什么是决策树2.2 特征选择的算法2.2.1 ID3:基于信息增益的特征划分2.2.2 C4.5:基于信息增益比的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,417
精华内容 5,366
关键字:

数据标准化进行随机森林分类