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

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 inenumerate(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 inenumerate(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对应的标签均值，绘制直方图。 defplot_keytarget_mean(df):
    target_mean = np.zeros(9)for i inrange(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 inrange(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 inrange(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 inrange(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 inenumerate(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