Disaster Tweets

题意：

就是给出一个dataframe包含text这一列代表着文本，文本会有一些词，问对于每条记录中的text是真关于灾难的还是假关于灾难的。
比如我们说今天作业真多，这真是一场灾难。实际上这个灾难只是我们调侃而言的。

数据处理：

1.首先要将文本转化为模型可以接受的数据。建立vectorizer将文本转换为词频矩阵，先fit训练数据，然后把这个vectorizer再应用到test数据上，这样才能保证测试数据和训练数据的一致性。
2.拆分训练集合和验证集合，对下面模型融合进行评估。

建立模型：

1.逻辑归回模型LogisticRegression，设置本模型的网格搜索参数，对lr进行超参数优化。
2.随机森林模型RandomForestClassifier，设置本模型的网格搜索参数，对rf进行超参数优化。
3.xgboost模型XGBClassifier，设置本模型的网格搜索参数，对xgb进行超参数优化。
4.投票模型融合，把三个算法的最佳参数下的模型进行融合训练，求出预测分数。只是把某个答案出现次数最多的作为答案。
5.加权模型融合，只是在投票模型的基础上，为每个模型分配一个权重。
6.堆叠模型融合，把三个模型输出答案作为次级模型的输入，再进行训练，预测出结果。逻辑回归模型会学习如何结合基模型的预测概率，以更准确地预测样本的类别。
例如，模型可能会学习到：
当基模型1和基模型3的预测概率较高时，样本更可能属于类别1。
当基模型2的预测概率较高时，样本更可能属于类别0。

代码：

import sys
import pandas as pd
from sklearn.ensemble import RandomForestClassifier, VotingClassifier, StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn import feature_extraction, model_selection
from sklearn.model_selection import GridSearchCV
from xgboost import XGBClassifier

if __name__ == '__main__':
    #数据处理
    data_train = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
    data_test = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
    vectorizer = feature_extraction.text.CountVectorizer()
    X_train = vectorizer.fit_transform(data_train['text'])
    Y_train = data_train['target']
    X_test = vectorizer.transform(data_test['text'])
    X_train,X_val,Y_train,Y_val = model_selection.train_test_split(X_train,Y_train,test_size=0.2,random_state=42)

    #lr模型
    lr_param_grid = {
        'penalty': ['l1', 'l2', 'elasticnet', None], #指定正则化类型，用于防止模型过拟合。
    #    'C': [0.001, 0.01, 0.1, 1, 10, 100], #正则化强度的倒数，值越小表示正则化越强。
    #    'solver': ['liblinear', 'saga'], #指定用于求解逻辑回归参数的优化算法。
    #    'class_weight': [None, 'balanced'] #指定类别权重，用于处理类别不平衡问题。
    }
    lr_model = GridSearchCV(
        estimator = LogisticRegression(random_state=42),  #对什么模型进行搜索超参数
        param_grid = lr_param_grid,  #超参数的候选值
        scoring = 'accuracy',  #使用准确率作为评估指标
        cv = 3,  #使用3折交叉验证
        n_jobs = -1,  #使用所有cpu并行运算
    )
    lr_model.fit(X_train, Y_train)
    print('lr预测分数：' + str(lr_model.score(X_val, Y_val)))

    #rf模型
    rf_param_grid = {
        'n_estimators': [50, 100, 200], #树的数量
    #    'max_depth': [None, 10, 20, 30], #树的最大深度
    #    'min_samples_split': [2, 5, 10], #节点分裂所需的最小样本数
    #    'min_samples_leaf': [1, 2, 4], #叶节点所需的最小样本数
    #    'max_features': ['auto', 'sqrt', 'log2'], #找最佳分裂时考虑的最大特征数
    #    'bootstrap': [True, False] #否使用有放回抽样构建树
    }
    rf_model = GridSearchCV(
        estimator=RandomForestClassifier(random_state=42),  # 对什么模型进行搜索超参数
        param_grid=rf_param_grid,  # 超参数的候选值
        scoring='accuracy',  # 使用准确率作为评估指标
        cv=3,  # 使用3折交叉验证
        n_jobs=-1,  # 使用所有cpu并行运算
    )
    rf_model.fit(X_train, Y_train)
    print('rf预测分数：' + str(rf_model.score(X_val, Y_val)))


    #xgb模型
    xgb_param_grid = {
        'n_estimators': [50, 100, 200], #树的数量
    #    'max_depth': [3, 4, 5, 6], #树的最大深度
    #    'learning_rate': [0.01, 0.1, 0.2], #学习速率
    #    'subsample': [0.8, 1.0], #指定每次迭代中用于训练每棵树的数据比例
    #    'colsample_bytree': [0.8, 1.0], #指定每次迭代中用于训练每棵树的特征比例
    #    'gamma': [0, 0.1, 0.2], #最小损失减少值
    #    'min_child_weight': [1, 3, 5], #子节点所需的最小样本权重和
    #    'reg_alpha': [0, 0.1, 1], #控制模型的正则化强度
    #    'reg_lambda': [0, 0.1, 1] #控制模型的正则化强度
    }
    xgb_model = GridSearchCV(
        estimator = XGBClassifier(random_state=42), #对什么模型进行搜索超参数
        param_grid = xgb_param_grid, #超参数的候选值
        scoring = 'accuracy', #使用准确率作为评估指标
        cv = 3, #使用3折交叉验证
        n_jobs = -1, #使用所有cpu并行运算
    )
    xgb_model.fit(X_train,Y_train)
    print('xgb预测分数：' + str(xgb_model.score(X_val, Y_val)))

    lr_best = lr_model.best_estimator_
    rf_best = rf_model.best_estimator_
    xgb_best = xgb_model.best_estimator_

    #投票模型融合
    voting_model = VotingClassifier(
        estimators=[('lr', lr_best), ('rf', rf_best), ('xgb', xgb_best)],
        voting='soft'  # 使用预测概率的平均值
    )
    voting_model.fit(X_train, Y_train)
    print('投票模型融合预测分数：' + str(voting_model.score(X_val, Y_val)))

    #加权投票模型融合
    lr_score = lr_model.score(X_val,Y_val)
    rf_score = rf_model.score(X_val,Y_val)
    xgb_score = xgb_model.score(X_val,Y_val)
    total_score = lr_score + rf_score + xgb_score
    weights = [lr_score / total_score, rf_score / total_score, xgb_score / total_score]
    weighted_voting_model = VotingClassifier(
        estimators=[('lr', lr_best), ('rf', rf_best), ('xgb', xgb_best)],
        voting='soft',
        weights=weights
    )
    weighted_voting_model.fit(X_train, Y_train)
    print('加权模型融合预测分数：' + str(weighted_voting_model.score(X_val, Y_val)))

    #堆叠模型融合
    stacking_model = StackingClassifier(
        estimators = [('lr', lr_best), ('rf', rf_best), ('xgb', xgb_best)],
        final_estimator=LogisticRegression(),
        cv=3  # 使用3折交叉验证生成元模型的训练数据
    )
    stacking_model.fit(X_train, Y_train)
    print('堆叠模型融合预测分数：' + str(stacking_model.score(X_val, Y_val)))


    Submission = pd.DataFrame({
        'id': data_test['id'],
        'target': stacking_model.predict(X_test)
    })
    Submission.to_csv('/kaggle/working/Submission.csv', index=False)