AI夏令营第三期用户新增挑战赛学习笔记

news2024/12/27 13:22:32

1、数据可视化

1.数据探索和理解：数据可视化可以帮助我们更好地理解数据集的特征、分布和关系。通过可视化数据，我们可以发现数据中的模式、异常值、缺失值等信息，从而更好地了解数据的特点和结构。

2.特征工程：数据可视化可以帮助我们选择和创建合适的特征。通过可视化特征与目标变量之间的关系，我们可以发现特征与目标之间的相关性、线性/非线性关系、重要性等信息，从而指导特征选择、变换和创建。

3.模型评估和调优：数据可视化可以帮助我们评估和比较不同模型的性能。通过可视化模型的预测结果、误差分布、学习曲线等信息，我们可以了解模型的准确性、稳定性、过拟合/欠拟合等情况，并根据可视化结果进行模型调优和改进。

4.结果解释和沟通：数据可视化可以帮助我们解释和传达机器学习模型的结果。通过可视化模型的预测、特征重要性、决策边界等信息，我们可以更直观地解释模型的工作原理和结果，使非技术人员也能理解和接受模型的输出。

5.发现洞察和故事讲述：数据可视化可以帮助我们发现数据中的洞察和故事，并将其传达给观众。通过可视化数据的趋势、关联、分布等信息，我们可以发现数据中的有趣模式、趋势和关系，并通过可视化故事的方式将这些发现传达给观众。

# 导入库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# 读取训练集和测试集文件
train_data = pd.read_csv('D:/D/Download/360安全浏览器下载/用户新增预测挑战赛公开数据/train.csv')
test_data = pd.read_csv('D:/D/Download/360安全浏览器下载/用户新增预测挑战赛公开数据/test.csv')

print(train_data.info())

在这里插入图片描述
通过pd库的df.info()方法查看数据框属性，发现只有udmap字段为类别类型，其余皆为数值类型。

# x7分组下标签均值
sns.barplot(x='x7', y='target', data=train_data)

在这里插入图片描述

# 相关性热力图
sns.heatmap(train_data.corr().abs(), cmap='YlOrRd')

在这里插入图片描述
相关性热力图颜色越深代表相关性越强，所以x7和x8变量之间的关系更加密切，还有common_ts与x6也是。即存在很强的多重共线性，进行特征工程时可以考虑剔除二者中的一个变量，以免导致因多重共线性造成的过拟合。
接下来对于每一个字段，绘制直方图和箱线图

# 列表，包含要分析的列名
cols = ['x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8']
# 对于每一个字段，绘制直方图
plt.figure(figsize=(15, 10))
for i, col in enumerate(cols):
    plt.subplot(2, 4, i+1)
    sns.histplot(train_data[col], bins=30, kde=True)
    plt.title(f'Histogram of {col}')
    plt.xlabel(col)
    plt.ylabel('Frequency')
plt.tight_layout()
plt.show()

# 对于每一个字段，绘制箱线图
plt.figure(figsize=(15, 10))
for i, col in enumerate(cols):
    plt.subplot(2, 4, i+1)
    sns.boxplot(train_data[col])
    plt.title(f'Boxplot of {col}')
    plt.xlabel(col)
plt.tight_layout()
plt.show()

结果如图所示：
在这里插入图片描述在这里插入图片描述

# 获取指定时间和日期
train_data['common_ts'] = pd.to_datetime(train_data['common_ts'], unit='ms')
# 从common_ts中提取小时
train_data['common_ts_hour'] = train_data['common_ts'].dt.hour
# 绘制每小时下标签分布变化
sns.barplot(x='common_ts_hour', y='target', data=train_data)
plt.show()

在这里插入图片描述可以发现在1-15小时之间新增用户的概率相对较大，尤其在8-15小时之间。后续可以针对这部分进行特征提取尝试。

# 定义函数，统计每个key对应的标签均值，绘制直方图。 
def plot_keytarget_mean(df):
    target_mean = np.zeros(9)
    for i in range(1, 10):
        df_temp = df.copy()
        number = 'key' + str(i)
        if number in df_temp.columns:
            data = {
                    f"{number}": df_temp[number],
                    'target': df_temp['target']
                    }
        df1 = pd.DataFrame(data)
        # 过滤出 "key" 列中非零值对应的行
        df_nonzero_key = df1[df1[number] != 0]
        # 计算非零值 "key" 对应的 "target" 均值
        mean_target_nonzero_key = df_nonzero_key['target'].mean()
        target_mean[i - 1] = mean_target_nonzero_key  # 索引从 0 开始
    return target_mean

target_mean = plot_keytarget_mean(train_data)
print(target_mean)
keys = ['key1', 'key2', 'key3', 'key4', 'key5', 'key6', 'key7', 'key8', 'key9']
plt.bar(keys, target_mean)
plt.ylabel('Mean Target Value')

在这里插入图片描述从上图看，特征key7，key8，key9对应的新增用户概率较大，后续可以做些相关的特征组合，尝试是否能够提高模型预测准确度。

总结

通过数据可视化，我们可以更详细地观察不同特征与目标之间的关系，从而帮助我们筛选出有用的特征，并进行特征组合，以进一步提高模型的预测准确性。并且可以更好地理解数据，发现数据中的模式和趋势，并根据这些发现来优化我们的建模过程。

2、特征工程

特征工程指的是把原始数据转变为模型训练数据的过程，目的是获取更好的训练数据特征。特征工程能使得模型的性能得到提升，有时甚至在简单的模型上也能取得不错的效果。
在这里插入图片描述

由数据可视化以及观察数据可知，时间是一个比较重要的特征。
因此添加分钟，星期，年等时间特征

train_data['common_ts_hour'] = train_data['common_ts'].dt.hour
test_data['common_ts_hour'] = test_data['common_ts'].dt.hour

train_data['common_ts_minute'] = train_data['common_ts'].dt.minute + train_data['common_ts_hour'] * 60
test_data['common_ts_minute'] = test_data['common_ts'].dt.minute + test_data['common_ts_hour'] * 60
train_data['dayofweek'] = train_data['common_ts'].dt.dayofweek
test_data['dayofweek'] = test_data['common_ts'].dt.dayofweek

train_data["weekofyear"] = train_data["common_ts"].dt.isocalendar().week.astype(int)
test_data["weekofyear"] = test_data["common_ts"].dt.isocalendar().week.astype(int)

train_data["dayofyear"] = train_data["common_ts"].dt.dayofyear
test_data["dayofyear"] = test_data["common_ts"].dt.dayofyear

train_data["day"] = train_data["common_ts"].dt.day
test_data["day"] = test_data["common_ts"].dt.day

train_data['is_weekend'] = train_data['dayofweek'] // 6
test_data['is_weekend'] = test_data['dayofweek'] // 6

发现week的值和用户增长有很大的关系，提交后发现分数提升至0.73+
在这里插入图片描述
然后继续添加学习文档中所给特征。发现存在缺失值需要填充，通过fillna用0填充缺失值。

# 提取x1~x8的频次特征和标签特征
for i in range(1, 9):
    train_data['x' + str(i) + '_freq'] = train_data['x' + str(i)].map(train_data['x' + str(i)].value_counts())
    test_data['x' + str(i) + '_freq'] = test_data['x' + str(i)].map(train_data['x' + str(i)].value_counts())
    test_data['x' + str(i) + '_freq'].fillna(test_data['x' + str(i) + '_freq'].mode()[0], inplace=True)
    train_data['x' + str(i) + '_mean'] = train_data['x' + str(i)].map(train_data.groupby('x' + str(i))['target'].mean())
    test_data['x' + str(i) + '_mean'] = test_data['x' + str(i)].map(train_data.groupby('x' + str(i))['target'].mean())
    test_data['x' + str(i) + '_mean'].fillna(test_data['x' + str(i) + '_mean'].mode()[0], inplace=True)
# 提取key1~key9的频次特征和标签特征
for i in range(1, 10):
    train_data['key'+str(i)+'_freq'] = train_data['key'+str(i)].map(train_data['key'+str(i)].value_counts())
    test_data['key'+str(i)+'_freq'] = test_data['key'+str(i)].map(train_data['key'+str(i)].value_counts())
    train_data['key'+str(i)+'_mean'] = train_data['key'+str(i)].map(train_data.groupby('key'+str(i))['target'].mean())
    test_data['key'+str(i)+'_mean'] = test_data['key'+str(i)].map(train_data.groupby('key'+str(i))['target'].mean())
 
train_data = train_data.fillna(0)
test_data = test_data.fillna(0)

然后通过其他助教的优秀笔记中说众数比0填充效果好尝试了一下他的特征，果然效果很好增加到0.75+。
在这里插入图片描述
具体代码如下：

train_data['x1_freq'] = train_data['x1'].map(train_data['x1'].value_counts())
test_data['x1_freq'] = test_data['x1'].map(train_data['x1'].value_counts())
test_data['x1_freq'].fillna(test_data['x1_freq'].mode()[0], inplace=True)
train_data['x1_mean'] = train_data['x1'].map(train_data.groupby('x1')['target'].mean())
test_data['x1_mean'] = test_data['x1'].map(train_data.groupby('x1')['target'].mean())
test_data['x1_mean'].fillna(test_data['x1_mean'].mode()[0], inplace=True)

train_data['x2_freq'] = train_data['x2'].map(train_data['x2'].value_counts())
test_data['x2_freq'] = test_data['x2'].map(train_data['x2'].value_counts())
test_data['x2_freq'].fillna(test_data['x2_freq'].mode()[0], inplace=True)
train_data['x2_mean'] = train_data['x2'].map(train_data.groupby('x2')['target'].mean())
test_data['x2_mean'] = test_data['x2'].map(train_data.groupby('x2')['target'].mean())
test_data['x2_mean'].fillna(test_data['x2_mean'].mode()[0], inplace=True)

train_data['x3_freq'] = train_data['x3'].map(train_data['x3'].value_counts())
test_data['x3_freq'] = test_data['x3'].map(train_data['x3'].value_counts())
test_data['x3_freq'].fillna(test_data['x3_freq'].mode()[0], inplace=True)

train_data['x4_freq'] = train_data['x4'].map(train_data['x4'].value_counts())
test_data['x4_freq'] = test_data['x4'].map(train_data['x4'].value_counts())
test_data['x4_freq'].fillna(test_data['x4_freq'].mode()[0], inplace=True)

train_data['x6_freq'] = train_data['x6'].map(train_data['x6'].value_counts())
test_data['x6_freq'] = test_data['x6'].map(train_data['x6'].value_counts())
test_data['x6_freq'].fillna(test_data['x6_freq'].mode()[0], inplace=True)
train_data['x6_mean'] = train_data['x6'].map(train_data.groupby('x6')['target'].mean())
test_data['x6_mean'] = test_data['x6'].map(train_data.groupby('x6')['target'].mean())
test_data['x6_mean'].fillna(test_data['x6_mean'].mode()[0], inplace=True)

train_data['x7_freq'] = train_data['x7'].map(train_data['x7'].value_counts())
test_data['x7_freq'] = test_data['x7'].map(train_data['x7'].value_counts())
test_data['x7_freq'].fillna(test_data['x7_freq'].mode()[0], inplace=True)
train_data['x7_mean'] = train_data['x7'].map(train_data.groupby('x7')['target'].mean())
test_data['x7_mean'] = test_data['x7'].map(train_data.groupby('x7')['target'].mean())
test_data['x7_mean'].fillna(test_data['x7_mean'].mode()[0], inplace=True)

train_data['x8_freq'] = train_data['x8'].map(train_data['x8'].value_counts())
test_data['x8_freq'] = test_data['x8'].map(train_data['x8'].value_counts())
test_data['x8_freq'].fillna(test_data['x8_freq'].mode()[0], inplace=True)
train_data['x8_mean'] = train_data['x8'].map(train_data.groupby('x8')['target'].mean())
test_data['x8_mean'] = test_data['x8'].map(train_data.groupby('x8')['target'].mean())
test_data['x8_mean'].fillna(test_data['x8_mean'].mode()[0], inplace=True)

3、模型交叉验证

交叉验证（Cross-Validation）是机器学习中常用的一种模型评估方法，用于评估模型的性能和泛化能力。
它的主要目的是在有限的数据集上，尽可能充分地利用数据来评估模型，避免过拟合或欠拟合，并提供对模型性能的更稳健的估计。
交叉验证的基本思想是将原始的训练数据划分为多个子集（也称为折叠），然后将模型训练和验证进行多次循环。
在每一次循环中，使用其中一个子集作为验证集，其他子集作为训练集。这样可以多次计算模型的性能指标，并取这些指标的平均值作为最终的模型性能评估结果。

1、为何使用交叉验证？

  • 交叉验证用于评估模型的预测性能，尤其是训练好的模型在新数据上的表现，可以在一定程度上减小过拟合。
  • 可以从有限的数据中获取尽可能多的有效信息。
  • 可以帮助我们选择最佳的模型参数。通过在不同的训练集和测试集上进行多次评估，可以比较不同参数设置下模型的性能，并选择最佳的参数组合。这有助于我们优化模型的性能，并提高预测准确性。

2、 常见的交叉验证方法：

  • 简单交叉验证
    将数据集分为两部分（或者是三部分），70%作为训练集，30%作为验证集。使用70%的数据，选择不同的模型参数，进行训练。结束后使用30%的数据（未经过训练）进行验证。选择最优的模型。
  • S折交叉验证
    将数据集分为规模大小相近的S个互不相交的数据集，利用S-1部分数据去训练模型，剩下的1部分数据进行验证 。经过多次训练选出最优的模型。
    【注意】每次的验证集都有可能不同。
  • 留一交叉验证
    其实就是S折交叉验证的特殊形式，即在数据集规模及其小的时候（小于100条，甚至更夸张）。将S折的S=N，其中N为数据规模。留下1条数据做验证。
# 导入模型
from sklearn.linear_model import SGDClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import MultinomialNB
from sklearn.ensemble import RandomForestClassifier

# 导入交叉验证和评价指标
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import classification_report

# 训练并验证SGDClassifier（基于随机梯度下降（Stochastic Gradient Descent）优化算法的分类器）
pred = cross_val_predict(
    SGDClassifier(max_iter=10),
    train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1),
    train_data['target']
)
print(classification_report(train_data['target'], pred, digits=3))

在这里插入图片描述
accuracy:准确率。准确率（precision）可以衡量一个样本为负的标签被判成正，召回率（recall）用于衡量所有正例。
macro avg："macro avg"是一种评估多类分类模型性能的指标之一。它是计算每个类别的指标（如准确度、精确度、召回率、F1值等），然后对所有类别的指标取平均得到的。
“micro”选项：表示在多分类中的对所有label进行micro-averaging产生一个平均precision，recall和F值
weighted avg:
“weighted”选项：表示会产生一个weighted-averaging的F值。
具体可见机器学习各种指标学习

# 训练并验证决策树DecisionTreeClassifier
pred = cross_val_predict(
    DecisionTreeClassifier(),
    train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1),
    train_data['target']
)
print(classification_report(train_data['target'], pred, digits=3))

在这里插入图片描述

# 训练并验证MultinomialNB
pred = cross_val_predict(
    MultinomialNB(),
    train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1),
    train_data['target']
)
print(classification_report(train_data['target'], pred, digits=3))

在这里插入图片描述

# 训练并验证RandomForestClassifier
pred = cross_val_predict(
    RandomForestClassifier(n_estimators=5),
    train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1),
    train_data['target']
)
print(classification_report(train_data['target'], pred, digits=3))

在这里插入图片描述
从上述四个模型来看决策树和随机森林表现较好，二者中决策树更好，我想决策树模型在本数据集上的优异表现可能是由于其对特征工程、数据分布、不平衡数据和特征交互效应的自然处理能力所致。当然，还应该进一步调整和优化所有模型的参数来进一步提高性能。
同时我又使用了XGBoost和LightgBM 两种模型进行交叉验证，效果如下：

import xgboost as xgb
import lightgbm as lgb
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_predict

# 定义XGBoost模型
xgb_model = xgb.XGBClassifier()
# 使用交叉验证进行训练和验证
pred_xgb = cross_val_predict(
    xgb_model,
    train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1),
    train_data['target']
)
print(classification_report(train_data['target'], pred_xgb, digits=3))

在这里插入图片描述

# 定义LightGBM模型
lgb_model = lgb.LGBMClassifier()
# 使用交叉验证进行训练和验证
pred_lgb = cross_val_predict(
    lgb_model,
    train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1),
    train_data['target']
)
print(classification_report(train_data['target'], pred_lgb, digits=3))

在这里插入图片描述
从macro avg和weightzvg的角度来看表现最好的还是决策树。

除此之外，模型本身的优化也不可忽视：
  • 超参数调优机器学习中有很多人为设定的模型参数，其中不是经过模型训练得到的参数叫做超参数（hyperparameter），人工根据特定问题对训练的模型进行调参可以提高模型的准确度。常用的超参数调优算法有贝叶斯优化、网格搜索和随机搜索。

1、贝叶斯优化：贝叶斯优化是一种基于贝叶斯定理的技术，它描述了与当前知识相关的事件发生的概率。将贝叶斯优化用于超参数优化时，算法会从一组超参数中构建一个概率模型，以优化特定指标。它使用回归分析迭代地选择最佳的一组超参数。

2、网格搜索：借助网格搜索，您可以指定一组超参数和性能指标，然后算法会遍历所有可能的组合来确定最佳匹配。网格搜索很好用，但它相对乏味且计算量大，特别是使用大量超参数时。
3、随机搜索：虽然随机搜索与网格搜索基于相似的原则，但随机搜索在每次迭代时会随机选择一组超参数。当相对较少的超参数主要决定模型的结果时，该方法效果良好。

看完一位0.86+大佬的随机森林调优笔记分享我尝试使用随机森林调优模型
通过设定已知效果较好的参数组合来提高tpe参数优化的效率

#设定已知好的参数组合：就默认的参数组合就已经很好了
good_params = {
  'n_estimators': 100,
  'max_depth': None, 
  'min_samples_split': 2
......
}
#这里的loss就是上面五交叉认证的相反数-score，将其转化为一个结果对象,加入trials:
good_result = {'loss': 0.95, 'status': STATUS_OK}
trials.insert_trial_docs([{
  'tid': len(trials) + 1,
  'spec': good_params,
  'result': good_result,
  'misc': {}
}])
#运行tpe搜索
best = fmin(fn=objective, space=space, algo=tpe.suggest, max_evals=100, trials=trials)

本次优化的参数：
n_estimators：随机森林模型中包含决策树模型的个数
max_depth：决策树模型的最大深度
max_features：用于构建决策树时选取的最大特征数量
min_samples_leaf：叶子节点最少样本数
min_samples_split：当前节点允许分裂的最小样本数
criterion：节点分裂依据

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV
import matplotlib.pyplot as plt
import time

n_estimators：随机森林模型中包含决策树模型的个数

#这里的train_data就是上面读入数据后，特征处理好后的待训练的数据
data = train_data.iloc[:,:-1]
lable = train_data.iloc[:,-1]
start=time.time()
scorel = []
for i in range(0,200,10): # 迭代建立包含0-200棵决策树的RF模型进行对比
  rfc = RandomForestClassifier(n_estimators=i+1,n_jobs=-1,random_state=90)
  score = cross_val_score(rfc,data,lable,cv=10).mean()
  scorel.append(score)
print(max(scorel),(scorel.index(max(scorel))*10)+1)
end=time.time()
print('Running time: %s Seconds'%(end-start))
plt.figure(figsize=[20,5])
plt.plot(range(1,201,10),scorel)
plt.show()

结果：

0.9613823613698237 131 Running time: 5530.6381804943085 Seconds
…

最后优化结果

clf = RandomForestClassifier(n_estimators=131,
                             max_depth=33,
                             n_jobs=-1,
                             max_features=9,
                             min_samples_leaf=1,
                             min_samples_split=2,
                             criterion = 'entropy'
                             )
clf.fit(
    train_data.drop(['target'], axis=1),
    train_data['target']
)
y_pred = clf.predict(X_val)
# 计算准确率
accuracy = accuracy_score(y_val, y_pred)
print("Accuracy:", accuracy)
# 计算F1分数
f1 = f1_score(y_val, y_pred)
print("F1 score:", f1)

提交上去分数达到0.79+
在这里插入图片描述
至此分数就上不去了，接下来的操作都是反向调优哈哈。
做了一下特征重要性得分，来评估各个特征对目标变量的影响程度

# 获取字段列表
l0 = ['x1_freq', 'x2_freq', 'x3_freq', 'x4_freq', 'x5_freq', 'x6_freq', 'x7_freq', 'x8_freq',
      'x1_mean', 'x2_mean', 'x3_mean', 'x4_mean', 'x5_mean', 'x6_mean', 'x7_mean', 'x8_mean',
      'x1_std', 'x2_std', 'x3_std', 'x4_std', 'x5_std', 'x6_std', 'x7_std', 'x8_std',
      'key1_freq', 'key2_freq', 'key3_freq', 'key4_freq', 'key5_freq', 'key6_freq', 'key7_freq', 'key8_freq', 'key9_freq',
      'key1_mean', 'key2_mean', 'key3_mean', 'key4_mean','key5_mean', 'key6_mean', 'key7_mean', 'key8_mean', 'key9_mean',
      'key1_std', 'key2_std', 'key3_std', 'key4_std', 'key5_std', 'key6_std', 'key7_std', 'key8_std', 'key9_std',
      'unmap_isunknown', 'udmap', 'common_ts', 'uuid', 'target', 'common_ts_hour', 'day', 'common_ts_minute','dayofweek',
      'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8',
      'eid', 'eid_std', 'eid_mean', 'eid_freq',
      'key1', 'key2', 'key3', 'key4', 'key5', 'key6', 'key7', 'key8', 'key9'
      ]
 
# 训练模型：按需分组选取特征
x = train_data.drop(['x1_freq', 'x2_freq', 'x3_freq', 'x4_freq', 'x5_freq', 'x6_freq', 'x7_freq', 'x8_freq',
                     'x1_mean', 'x2_mean', 'x3_mean', 'x4_mean', 'x5_mean', 'x6_mean', 'x7_mean', 'x8_mean',
                     'x1_std', 'x2_std', 'x3_std', 'x4_std', 'x5_std', 'x6_std', 'x7_std', 'x8_std',
                     'key1_freq', 'key2_freq', 'key3_freq', 'key4_freq', 'key5_freq', 'key6_freq', 'key7_freq', 'key8_freq','key9_freq',
                     'key1_mean', 'key2_mean', 'key3_mean', 'key4_mean','key5_mean', 'key6_mean', 'key7_mean', 'key8_mean','key9_mean',
                     'key1_std', 'key2_std', 'key3_std', 'key4_std', 'key5_std', 'key6_std', 'key7_std', 'key8_std', 'key9_std',
                     'udmap', 'common_ts', 'uuid', 'target', 'common_ts_hour', 'day', 'common_ts_minute','dayofweek',
                     'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8',
                     'eid', 'eid_std', 'eid_mean', 'eid_freq',
                     'key1', 'key2', 'key3', 'key4', 'key5', 'key6', 'key7', 'key8', 'key9'
                      ], axis=1)
y = train_data['target']
clf = DecisionTreeClassifier()
clf.fit(x, y)
 
# 获取特征重要性得分
feature_importances = clf.feature_importances_
 
# 创建特征名列表
feature_names = list(x.columns)
 
# 创建一个DataFrame，包含特征名和其重要性得分
feature_importances_df = pd.DataFrame({'feature': feature_names, 'importance': feature_importances})
 
# 对特征重要性得分进行排序
feature_importances_df = feature_importances_df.sort_values('importance', ascending=False)
 
# 颜色映射
colors = plt.cm.viridis(np.linspace(0, 1, len(feature_names)))
 
# 可视化特征重要性
fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(feature_importances_df['feature'], feature_importances_df['importance'], color=colors)
ax.invert_yaxis()  # 翻转y轴，使得最大的特征在最上面
ax.set_xlabel('特征重要性', fontsize=12)  # 图形的x标签
ax.set_title('决策树特征重要性可视化', fontsize=16)
for i, v in enumerate(feature_importances_df['importance']):
    ax.text(v + 0.01, i, str(round(v, 3)), va='center', fontname='Times New Roman', fontsize=10)
 
# 保存图形
plt.savefig('./特征重要性.jpg', dpi=400, bbox_inches='tight')
plt.show()


结果显示时间特征年份最重要，，

# 使用Decision Tree Classifier对模型进行训练
clf = DecisionTreeClassifier()
X = train_data.drop(['udmap', 'common_ts', 'uuid', 'target'], axis=1)
y = train_data['target']
clf.fit(X, y)
# 绘制特征重要性柱状图
import matplotlib.pyplot as plt
# 获取特征重要性分数
feature_importances = clf.feature_importances_

# 创建特征重要性 DataFrame
importance_df = pd.DataFrame({'Feature': X.columns, 'Importance': feature_importances})

# 按重要性从大到小排序
importance_df = importance_df.sort_values(by='Importance', ascending=False)
plt.figure(figsize=(80, 6))
plt.bar(importance_df['Feature'], importance_df['Importance'])

接着绘制了一个绘制决策树特征重要性柱状图
在这里插入图片描述
利用重要的commom_ts时间特征的week, day, or minute去与target做特征组合,但是效果似乎不咋好，不如之前提取的特征分数高
在这里插入图片描述
最后介绍暗最高分的来源——AutoGluon
只需几行代码即可在原始数据上构建机器学习解决方案。
哈哈先上代码

pip install autogluon

import numpy as np
import pandas as pd
from autogluon.tabular import TabularDataset
from autogluon.tabular import TabularPredictor

train_data = TabularDataset('D:/D/Download/360安全浏览器下载/用户新增预测挑战赛公开数据/train.csv')
test_data = TabularDataset('D:/D/Download/360安全浏览器下载/用户新增预测挑战赛公开数据/test.csv')
submit = pd.DataFrame()
submit["uuid"] = test_data["uuid"]
label = "target"

predictor = TabularPredictor(
    label = label,
    problem_type="binary",
    eval_metric="f1"
).fit(
    train_data.drop(columns=["uuid"]),
    excluded_model_types=[
        "CAT",
        "NN_TORCH",
        "FASTAI",
    ],
)

submit[f"{label}"] = predictor.predict(test_data.drop(columns=["uuid"]))
submit.to_csv("D:/D/Download/360安全浏览器下载/用户新增预测挑战赛公开数据/submit.csv",index=False)

就这几行代码，我弄了几天都赶不上哈哈有点儿丢人。
在这里插入图片描述
关于AutoGluon

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/929539.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[Linux]文件IO

[Linux]文件IO

文章目录 1. 文件描述符1.1 虚拟地址空间1.1.1 存在的意义1.1.2 分区 1.2 文件描述符1.2.1 文件描述符1.2.2 文件描述符表 2. Linux系统文件IO2.1 open/close2.1.1 函数原型2.1.2 close函数原型2.1.3 打开已存在文件2.1.4 创建新文件2.1.5 文件状态判断 2.2 read/write2.2.1 re…
阅读更多...
论文解读 | ScanNet：室内场景的丰富注释3D重建

论文解读 | ScanNet：室内场景的丰富注释3D重建

原创 | 文 BFT机器人 大型的、有标记的数据集的可用性是为了利用做有监督的深度学习方法的一个关键要求。但是在RGB-D场景理解的背景下，可用的数据非常少,通常是当前的数据集覆盖了一小范围的场景视图，并且具有有限的语义注释。 为了解决这个问题&#…
阅读更多...
C++学习记录——이십오 C++11（1）

C++学习记录——이십오 C++11（1）

文章目录 1、列表初始化2、声明decltype 3、STL新容器小总结 4、右值引用1、概念2、使用场景（包含移动构造）3、完美转发4、移动赋值5、C98的const引用延长生命周期 1、列表初始化 大括号{}来代替初始化，并且是所有类型。 struct ZZ {int _x…
阅读更多...
RabbitMQ---订阅模型-Fanout

RabbitMQ---订阅模型-Fanout

1、 订阅模型-Fanout Fanout，也称为广播。 流程图： 在广播模式下，消息发送流程是这样的： 1） 可以有多个消费者 2） 每个消费者有自己的queue（队列） 3） 每个队列都要绑定…
阅读更多...
记录 JSONObject.parseObject json对象转换 对象字段为null

记录 JSONObject.parseObject json对象转换 对象字段为null

1.业务背景 使用websocket 接收消息都是String类型，没办法自定义实体类接收，所以接发都必须将json 转 对象 对象转 json。 这是我最开始的实体类，也就是转换的类型 package com.trinity.system.domain;import lombok.AllArgsConstructor; im…
阅读更多...
浏览器跨域

浏览器跨域

生活中的事跟跨域有什么关系，那必须有。 跨域的产生是浏览器的安全机制引起的，只有在使用Ajax时才会发生。简单来说就是你可以通过ajax发送请求，但要看远程服务器脸色，他没授权，浏览器这个老六就给拦截了，不…
阅读更多...
Java之ApI之Math类详解

Java之ApI之Math类详解

1 Math类 1.1 概述 tips：了解内容 查看API文档，我们可以看到API文档中关于Math类的定义如下： Math类所在包为java.lang包，因此在使用的时候不需要进行导包。并且Math类被final修饰了，因此该类是不能被继承的。 Math类…
阅读更多...
6.基于二阶锥规划的主动配电网最优潮流求解

6.基于二阶锥规划的主动配电网最优潮流求解

matlab代码： 6.基于二阶锥规划的主动配电网最优潮流求解 参考文献：主动配电网多源协同运行优化研究_乔珊 摘要：最优潮流研究在配 电网规划运行 中不可或缺 ， 且在大量分布式能源接入 的主动配 电网环境下尤 为重要 。传统的启发…
阅读更多...
Spring 与【MyBatis 】和【 pageHelper分页插件 】整合

Spring 与【MyBatis 】和【 pageHelper分页插件 】整合

目录 一、Spring整合MyBatis 1. 导入pom依赖 2. 利用mybatis逆向工程生成模型层层代码 3. 编写配置文件 4. 注解式开发 5. 编写Junit测试类 二、AOP整合pageHelper分页插件 1. 创建一个AOP切面 2. Around("execution(* *..*xxx.*xxx(..))") 表达式解析 3. 编…
阅读更多...
Java IDEA Web 项目 1、创建

Java IDEA Web 项目 1、创建

环境： IEDA 版本：2023.2 JDK：1.8 Tomcat：apache-tomcat-9.0.58 maven：尚未研究 自行完成 IDEA、JDK、Tomcat等安装配置。 创建项目： IDEA -> New Project 选择 Jakarta EE Template：选择…
阅读更多...
一文了解SpringBoot中的Aop

一文了解SpringBoot中的Aop

目录 1.什么是Aop 2.相关概念 3.相关注解 4.为什么要用Aop 5.Aop使用案例 1.什么是Aop AOP：Aspect Oriented Programming，面向切面，是Spring三大思想之一，另外两个是 IOC-控制反转 DI-依赖注入 (Autowired、Qualifier、Re…
阅读更多...
LabVIEW开发灭火器机器人

LabVIEW开发灭火器机器人

LabVIEW开发灭火器机器人 如今，自主机器人在行业中有着巨大的需求。这是因为它们根据不同情况的适应性。由于消防员很难进入高风险区域，自主机器人出现了。该机器人具有自行检测火灾的能力，并通过自己的决定穿越路径。 由于消防安全是主要问…
阅读更多...
JAVA设计模式第十二讲：大厂实践 - 美团: 设计模式二三事

JAVA设计模式第十二讲：大厂实践 - 美团: 设计模式二三事

JAVA设计模式第十二讲：大厂实践 - 美团: 设计模式二三事 设计模式是众多软件开发人员经过长时间的试错和应用总结出来的，解决特定问题的一系列方案。现行的部分教材在介绍设计模式时，有些会因为案例脱离实际应用场景而令人费解，有…
阅读更多...
windows上sqlserver的ldf日志文件和数据mdf文件分别放到不同的磁盘

windows上sqlserver的ldf日志文件和数据mdf文件分别放到不同的磁盘

之前我的windows上已安装好了sqlserver2017，有一个名为TestDb的数据库。ldf文件和mdf文件都一起放在D:\Database目录下。现在需要把ldf日志文件到E盘的database目录下。 重要的事情先说三遍 先停止网关（例如nginx）并备份数据库 先停止网关&am…
阅读更多...
2023泉城杯 easy_log的解题

2023泉城杯 easy_log的解题

压缩包解压里面是一个 access.log 日志文件。 捋数据 进行过远程命令执行 这个后续没啥用 可疑字符串 可疑字符串/upload/ma.php?logvar_dump(%27cGFzc3dvcmQ6IHNAZncjdiVmOQ%27);这个首先就判断是不是base64编码（英文大小写、数字和、/）以及用作后缀…
阅读更多...
深度学习：Sigmoid函数与Sigmoid层区别

深度学习：Sigmoid函数与Sigmoid层区别

深度学习：Sigmoid函数与Sigmoid层 1. Sigmoid神经网络层 vs. Sigmoid激活函数 在深度学习和神经网络中，“Sigmoid” 是一个常见的术语，通常用来表示两个相关但不同的概念：Sigmoid激活函数和Sigmoid神经网络层。这两者在神经网络…
阅读更多...
【广州华锐互动】VR高校虚拟实验教学平台提供丰富的资源支持，提高教学效果

【广州华锐互动】VR高校虚拟实验教学平台提供丰富的资源支持，提高教学效果

随着科技的不断进步，虚拟现实(VR)技术已经逐渐渗透到各个领域，其中包括教育。 广州华锐互动利用VR虚拟现实技术打造的VR高校虚拟实验教学平台，是一种新型的教学工具，它提供了一个在线的教学资源管理平台，包含教学平台、…
阅读更多...
homeassistant ubuntu自启动 网络设置

homeassistant ubuntu自启动 网络设置

命令行安装virtualbox 或者安装包 hass官网下载 haos_ova-10.4.vdi virtualbox 装hass 最少2G内存 其他省略 自启动： gnome-session-properties 添加 VBoxManage startvm hass --type headless hass为自己的虚拟机名字 网络配置如下： 要全部打开
阅读更多...
在 AWS 中导入 qcow2 镜像

在 AWS 中导入 qcow2 镜像

文章目录 在 AWS 中导入 qcow2 镜像使用的格式和问题步骤概述前提条件转换镜像格式并上传至 S3创建角色并配置策略策略文件内容创建container.json配置文件导入镜像创建 AMI 并启动实例参考:在 AWS 中导入 qcow2 镜像 当我们在多云环境中部署应用时，有时候可能需要把基于 qem…
阅读更多...
Python爬虫 异步、缓存技巧

Python爬虫 异步、缓存技巧

在进行大规模数据抓取时，Python爬虫的速度和效率是至关重要的。本文将介绍如何通过异步请求、缓存和代理池等技巧来优化Python爬虫的速度和性能。我们提供了实用的方案和代码示例，帮助你加速数据抓取过程，提高爬虫的效率。 使用异步请求、缓…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023