【新人赛】阿里云恶意程序检测 -- 实践记录10.27

TF-IDF模型调参

1. 调TfidfVectorizer的参数 ngram_range, min_df, max_df：

上一篇博客调了ngram_range这个参数，得出了ngram_range=(1, 4)时效果最好这个结论，并在线上验证了下。

本篇博客继续调其他的参数。考虑到训练的速度，先将ngram_range设置为(1, 1)，调min_df:

min_df	train-mlogloss	val-mlogloss
1	0.103793	0.406085
2	0.1091895	0.4051025
3	0.1098425	0.4057675
4	0.1105005	0.406762

通过以上调参可以看到，似乎min_df=2时在验证集上效果最好，再继续增大反而更差。

将ngram_range设置为(1, 2)，可以看到：

min_df	train-mlogloss	val-mlogloss
1	0.0761615	0.3467905
2	0.071733	0.3457505
3	0.0752675	0.3465775
4	0.077503	0.3472625

ngram_range设置为(1, 2)时，也是min_df=2时效果最好。

调参数 max_df:

ngram_range设置为(1, 2)，min_df设置为2。

max_df	train-mlogloss	val-mlogloss
1.0	0.071733	0.3457505
0.98	0.071733	0.3457505
0.95	0.071733	0.3457505
0.9	0.0827205	0.348275
0.8	0.083161	0.3503905

根据调参情况，max_df取1.0比较好。

比对线上结果:

在上一篇博客中，ngram_range=(1, 4), min_df=1, max_df=1.0得到的结果为：

train-mlogloss: 0.06831 val-mlogloss: 0.336836 test-mlogloss: 0.522686

现在只修改min_df=2，其他两个参数ngram_range=(1, 4), max_df=1.0：

train-mlogloss: 0.0696595 val-mlogloss: 0.336026 test-mlogloss: 0.524699

min_df调为2，在训练集和测试集上效果都不好了，仅在验证集上有些许提升，所以min_df的值应当取为1。

由此可见文件中的API，无论其数量多少，都是有用的。

最终TfidfVectorizer的参数设置为 ngram_range=(1, 4), min_df=1, max_df=1.0

2. 调xgboost的参数 subsample, colsample_bytree, max_depth, eta:

XGBoost参数解析：

eta [default=0.3, alias: learning_rate] 学习率

max_depth [default=6] 树的最大深度，可以用来防止过拟合，典型值是3-10

colsample_bytree [default=1] 列采样率，也就是特征采样率

subsample [default=1] 构建每棵树对样本的采样率，如果设置成0.5，XGBoost会随机选择一半的样本作为训练集

objective[默认reg:linear] 损失函数，multi:softprob：和softmax一样，但是返回的是每个数据属于各个类别的概率

num_class（softmax分类的个数）

eval_metric 对于有效数据的度量方法，mlogloss 多分类logloss损失函数

silent [default=0] 取0时表示打印出运行时信息，取1时表示以缄默方式运行，不打印运行时信息

# 上篇博客设置的参数：

param = {'max_depth': 6, 'eta': 0.1, 'eval_metric': 'mlogloss', 'silent': 1, 'objective': 'multi:softprob',

             'num_class': 8, 'subsample': 0.8, 'colsample_bytree': 0.85}

为了提高速度，先将ngram_range设置为(1, 2)，TfidfVectorizer的其他参数不变。

subsample参数控制对于每棵树，随机采样的比例。减小这个参数的值，算法会更加保守，避免过拟合。但是，如果这个值设置得过小，它可能会导致欠拟合。一般在0.5-1。

调参数subsample，xgboost的其他参数不变：

subsample	train-mlogloss	val-mlogloss
1.0	0.078896	0.348712
0.9	0.0770755	0.3458625
0.8	0.0761615	0.3467905
0.7	0.077435	0.3451595
0.6	0.0811085	0.3463795
0.5	0.0791555	0.348638

subsample可以取0.7-0.9之间的数。

3. 数据可视化：

训练集和测试集的数据分布：

上一篇博客中已计算出，训练集label统计：

import pandas as pd

train_path = './security_train.csv'

df = pd.read_csv(train_path)

df = df.drop(['api', 'tid', 'index'], axis=1)

df = df.drop_duplicates()

df['label'].value_counts() / df.label.count()

0 0.358465

5 0.308850

7 0.107079

2 0.086124

3 0.059048

6 0.037085

1 0.036149

4 0.007201

Name: label, dtype: float64

测试集label统计(通过线上提交数据获取)：

提交文件中，将其中一列prob设为1，其他列置为0提交，共8次，得到一个test-mlogloss数组，

将其中一列设为0.3，其他列置为0.1提交，也是8次，再得到一个test-mlogloss数组。（代码中的result1, result2）

from math import log

result1 = [17.013720, 26.758693, 26.259607, 26.202020, 27.370820, 18.485384, 26.289467, 25.037486] # 全1全0

result2 = [2.772709, 3.248805, 3.224422, 3.221608, 3.278711, 2.844608, 3.225881, 3.164714] # 0.3 / 0.1

for i in range(0, len(result1)):

  result1[i] *= -12955

for i in range(0, len(result2)):

  result2[i] *= -12955

# 情况1：全1全0

# 预测正确 8*log(1-1e-6)

# 预测错误 6*log(1-1e-6) + 2*log(1e-6)

r = 8*log(1-1e-6)

e = 6*log(1-1e-6) + 2*log(1e-6)

# 情况2：0.3/0.1

# 预测0.3 log(0.3) + 7*log(0.9)

# 预测0.1 log(0.7) + log(0.1) + 6*log(0.9)

r2 = log(0.3) + 7*log(0.9)

e2 = log(0.7) + log(0.1) + 6*log(0.9)

lst = []

for i in range(0, len(result1)):

  temp = (result1[i] - 12955*e)/(r - e)

  lst.append(round(temp))

print(lst)

lst2 = []

for i in range(0, len(result2)):

  temp = (result2[i] - 12955*e2)/(r2 - e2)

  lst2.append(round(temp))

print(lst2 == lst)

[4978, 409, 643, 670, 122, 4288, 629, 1216]

True

import matplotlib.pyplot as plt

import numpy as np

trainlst = [4978, 502, 1196, 820, 100, 4289, 515, 1487]

testlst = [4978, 409, 643, 670, 122, 4288, 629, 1216]

for i in range(len(trainlst)):

  testlst[i] /= 12955

  trainlst[i] /= 13877

print("训练数据比例：", trainlst)

print("测试数据比例：", testlst)

# 绘制对比柱状图

bar_width = 0.3

plt.bar(x=range(len(trainlst)), height=trainlst, label="train data", alpha=0.8, width=bar_width)

plt.bar(x=np.arange(len(trainlst)) + bar_width, height=testlst, label="test data", alpha=0.8, width=bar_width)

plt.legend()

plt.xlabel("label")

plt.ylabel("percent")

plt.title('data distribution')

plt.show()

训练数据比例： [0.3587230669453052, 0.036174965770699716, 0.08618577502342005, 0.05909058153779635, 0.007206168480219067, 0.3090725661165958, 0.037111767673128196, 0.10715572530085754]

测试数据比例： [0.38425318409880355, 0.03157082207641837, 0.049633346198379, 0.05171748359706677, 0.00941721343110768, 0.33099189502122733, 0.048552682362022384, 0.09386337321497491]

比较两个分布的差异：

KL散度：有时也称为相对熵，KL距离。对于两个概率分布P、Q，二者越相似，KL散度越小。KL散度是不对称的。

import numpy as np

import scipy.stats

p=np.asarray(trainlst)

q=np.asarray(testlst)

def KL_divergence(p,q):

    return scipy.stats.entropy(p, q)

print(KL_divergence(p,q))

print(KL_divergence(q,p))

0.016080060925276304

0.014372032451801856

测试集与训练集API数量分布的差异：

import pandas as pd

train_path = './security_train.csv'

df = pd.read_csv(train_path)

test_path = './security_test.csv'

df_test = pd.read_csv(test_path)

train_api_cnt = df.api.value_counts()

test_api_cnt = df_test.api.value_counts()

len(train_api_cnt) # 295

len(test_api_cnt) # 298

name_train = train_api_cnt.index.tolist()

value_train = train_api_cnt.tolist()

name_test = test_api_cnt.index.tolist()

value_test = test_api_cnt.tolist()

print("=== 只有训练集中有的api ===")

for i in range(len(train_api_cnt)):

  if name_train[i] not in name_test:

    print(name_train[i], value_train[i])

print("=== 只有测试集中有的api ===")

for i in range(len(test_api_cnt)):

  if name_test[i] not in name_train:

    print(name_test[i], value_test[i])

=== 只有训练集中有的api及调用次数 ===

RtlCompressBuffer 68

WSASendTo 2

EncryptMessage 1

=== 只有测试集中有的api及调用次数 ===

InternetGetConnectedStateExA 6

CreateDirectoryExW 4

MessageBoxTimeoutW 3

TaskDialog 1

NtDeleteFile 1

NtCreateUserProcess 1

由此可以看出，训练集和测试集调用的api有一些不同。

进一步分析训练集和测试集调用的api的数量差异：

name_differ = [] # 占比不同的api的名称

value_differ = [] # 加权过的api占比差值

rate = len(df) / len(df_test) # 权值 1.1326590184248322

for i in range(len(train_api_cnt)):

  if name_train[i] in name_test:

    differi = abs(value_train[i] - test_api_cnt[name_train[i]] * rate) / max(value_train[i], test_api_cnt[name_train[i]] * rate)

    if differi > 0.3:

      name_differ.append(name_train[i])

      value_differ.append(differi)

differ = pd.Series(value_differ, index=name_differ)

differ.sort_values(ascending=False)

recvfrom 0.987882

WSASend 0.977791

CryptEncrypt 0.969303

CertOpenSystemStoreA 0.954694

CryptUnprotectData 0.921522

...

CryptHashData 0.310428

CoCreateInstanceEx 0.306535

EnumServicesStatusW 0.306310

GetSystemDirectoryA 0.304643

GetFileVersionInfoW 0.302142

Length: 75, dtype: float64

简单通过数据集大小加权后，api调用的加权次数相比较，差值超过30%的api竟有75个之多。

由此可见虽然调用的api种类差不多，但数量上存在巨大差异。

虽然训练集和测试集的分布差异不大，但是api的调用次数比例差异很大。

由此可以得出一个初步结论：文件分类与api调用了多少次关系不大，可能与调用了哪种api以及api调用的序列有关。

以下从训练集来分析。

不同类别的文件调用api种类的差异：

不同label调用的api种类数：

df_temp = df.drop(['file_id', 'tid', 'index'], axis=1).drop_duplicates()

group_label = df_temp.groupby('label')

group_label['label'].count()

label

0 288

1 218

2 247

3 211

4 183

5 261

6 240

7 260

Name: label, dtype: int64

各种api出现在多少种文件中：

df_temp.groupby('api').label.count().sort_values(ascending=False)

api

NtOpenThread 8

NtQueryInformationFile 8

NtResumeThread 8

GetShortPathNameW 8

NtReadFile 8

..

InternetGetConnectedStateExW 1

CryptUnprotectData 1

GetUserNameExA 1

EncryptMessage 1

NetUserGetLocalGroups 1

Name: label, Length: 295, dtype: int64

简单统计了一下。

df_temp.groupby('api').label.count().sort_values(ascending=False).value_counts()

8 165

7 32

6 28

1 18

2 15

5 13

3 13

4 11

Name: label, dtype: int64

其中有一半以上的api是会出现在所有类型的文件中的，只出现在某一文件中的api很少。

由此可见，文件类型更多是与文件的行为有关，即api的调用序列有关，之后的模型训练应该主要从此下手。

组会总结

数据挖掘方向比较偏重于对于数据的统计特征之类的分析，组合特征做的比较好也可能带来很大的提升，文本处理方向侧重于用一些深度模型之类的方法来做；
one-hot表示法的缺点：维度高，没法算距离；
textcnn和n-gram比较相似，向前向后填充影响不会很大，但是lstm必须要在前面填充。（具体看paper）
Xgboost调参
Fasttest最新自动调参