达观杯文本处理模型实践

tf-idf+lr

采用前文处理的tf-idf文件进行简单的模型预测，没有加入交叉验证。
代码如下：

这里用到了前几篇文章中处理的数据，用pickle读取即可，当时之所以分批保存到不同的pickle文件是因为内存不够直接存在一个文件中内存报错，所以选择了分别存取。
我们可以看到每一个文件被处理成200多万维度的向量，显然比较大，后期准备使用pca处理一下(这个想法直接pass掉吧，因为维度太大了，pca处理不了)，先简单的用lr跑一下。

这个结果提交到达观杯官网上结果是0.77256，作为baseline，后期再改进。

tf-idf+svm

用了之前的处理的tf-idf数据，然后试了试svm模型，质量相比lr有提高但是复读不大附上代码吧

word2vec+svm

整体思路是把每一个文章中的每一个词的词向量叠加起来然后取平均，然后处理成300维度的向量，放到svm中训练。

x_train=w_arr(df_train)
x_test=w_arr(df_test)
import pickle
###把处理的文件转化成pickle序列化存储起来，下次使用比较方便
fp = open('data_w_vec_train_x.pkl', 'rb')
x_train=pickle.load( fp)
fp = open('data_w_vec_text_x.pkl', 'rb')
x_test=pickle.load(fp)
fp.close()

SVM

from sklearn import svm
svclf = svm.LinearSVC() 
svclf.fit(x_train,y_train)
preds = svclf.predict(x_test)
submit['class']=list(preds)
submit.to_csv('./data/submit_svm_wv.csv',index=False)

最后提交的分数很低，0.71,应该文本太长了然后把词向量叠加起来应该损坏了词向量。
然后试了试lda分解直接把内存撑爆。

tf-idf+lgb

以为降维的话200维内存扛不住，太低效果很差，所以直接就把数据塞进lgb里面，然后因为数据量太大，所以只选取了其中的50%的数据训练。

import lightgbm as lgb
import pickle
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

f=open('./data_w_tfidf_train.pkl','rb')
x_train=pickle.load(f)
f=open('./data_w_tfidf_test.pkl','rb')
x_test=pickle.load(f)
f=open('./data_w_tfidf_train_y.pkl','rb')
y_train=pickle.load(f)
params = {
       'boosting': 'gbdt',
        'application': 'multiclass',
        'num_class': 20,
        'learning_rate': 0.1,
        'num_leaves':31,
        'max_depth':-1,
        'lambda_l1': 0,
        'lambda_l2': 0.5,
        'bagging_fraction' :1.0,
        'feature_fraction': 1.0,
        'bagging_freq': 5,  # k 意味着每 k 次迭代执行bagging
        'verbose': 1 ,# <0 显示致命的, =0 显示错误 (警告), >0 显示信息
        }


x_train, x_vali, y_train, y_vali = train_test_split(x_train, y_train, test_size=0.5, random_state=0)
d_train = lgb.Dataset(data=x_train, label=y_train)
d_vali = lgb.Dataset(data=x_vali, label=y_vali)

bst = lgb.train(params, d_train, num_boost_round=200, valid_sets=d_vali,early_stopping_rounds=100)
y_test = np.argmax(bst.predict(x_test), axis=1)

结果并不理想，等再研究研究怎么多次训练模型。先到这。

模型融合

因为是在在提供的免费的cpu上，所以不能安装mlxtend,所以参考网上的stacking代码。

import pickle
import pandas as pd
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import LinearSVC
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

f=open('./dgb_data/x_train_tfidf.pkl','rb')
x_train_tfidf=pickle.load(f)
f.close()
f=open('./dgb_data/x_test_tfidf.pkl','rb')
x_test_tfidf=pickle.load(f)
f.close()

from sklearn.cross_validation import cross_val_score
from sklearn.model_selection import  train_test_split
import numpy as np
from sklearn.cross_validation import StratifiedKFold

clf_svm=LinearSVC()
clf_lr=LogisticRegression(C=4)
clf_rfc=RandomForestClassifier(n_estimators=500, criterion='entropy', max_depth=5, min_samples_split=2,
  min_samples_leaf=1, max_features='auto', bootstrap=False, oob_score=False, n_jobs=1, random_state=0,
  verbose=0)
clf_nb=MultinomialNB()

x_trian,x_val,y_train, y_val = train_test_split(x_train_tfidf, y_train1, test_size=0.2, random_state=2019)
clfs=[clf_svm,clf_lr,clf_rfc,clf_nb]
dataset_blend_train = np.zeros((x_trian.shape[0], len(clfs)))
dataset_blend_test = np.zeros((x_val.shape[0], len(clfs)))

skf = StratifiedKFold(y_train1['class'], n_folds=5)

for j, clf in enumerate(clfs):
    #dataset_blend_test_j = np.zeros((x_val.shape[0], len(skf)))
    for i, (train, test) in enumerate(skf):
        '''使用第i个部分作为预测，剩余的部分来训练模型，获得其预测的输出作为第i部分的新特征。'''
        X_train, Y_train, X_test, Y_test = x_train_tfidf[train], y_train1.iloc[train], x_train_tfidf[test], y_train1.iloc[test]
        clf.fit(X_train, Y_train)
        y_submission = clf.predict(X_test)
        dataset_blend_train[test, j] = y_submission
clf_svm.fit(dataset_blend_train,y_train1)
pre=clf.predict(x_test_tfidf)
submit_stacking['class']=pre
pre.to_csv('./data/submit_stacking.csv')