食品与疾病关系预测算法赛道-baseline食品与疾病关系预测算法赛道-baseline

★★★ 本文源自AlStudio社区精品项目，【点击此处】查看更多精品内容 >>>

一、赛题背景

电子病历、人工智能、物联网设备、5G技术的快速演化，与大规模的数据资源，成为了数字化医疗的全新支撑。
对于医药公司、医疗机构、科技公司，如何整合全新的技术能力、人才资源、数据资源，为数字化医疗的创新提供更强的动力，成为了共同关切的重要话题。

本次数字医疗算法应用创新大赛是对于这一重要话题的主动探索，旨在最大化利用当前高速发展的算法技术与数据资源，培养数字化医疗人才、激励数字化医疗创新。大赛双赛道分别为食品与疾病关系预测算法赛道和生物共融与数字疗法应用赛道。

1.1 赛题任务

本赛道将提供脱敏后的食物与疾病特征，参赛团队根据主办方提供数据，在高度稀疏数据的场景中，进一步挖掘、融合特征并设计模型，以预测食物与疾病的关系。初赛阶段为二分类问题，分类标签分别为 0（无关）、1（存在正面或负面的影响）。

1.2 赛题数据简介

本次算法赛将提供超过 23.5W 的食物、疾病对应关系及其量化得分，其中食物特征超过 200 个，疾病特征由 3 种不同的方式抽取，累积超过 4000 个特征信息。初赛为 0、1 二分类预测，提供食物、疾病特征，与食物疾病的关系标签。

复赛阶段同时评估 0、1 二分类与相关性评级，在原训练集中增加食物疾病相关性评级的标签数据。

1.2.1 训练集

训练集包括疾病特征数据、食物特征数据（共计 348 种食物）、以及食物疾病关系，用于模型训练：

• 疾病特征集：disease_feature1.csv、disease_feature2.csv、disease_feature3.csv
• 食物特征集：train_food.csv
• 食物疾病关系：train_answer.csv
• 「复赛阶段」食物与疾病关系的相关性评级：semi_train_answer.csv

1.2.2 测试集

初赛测试集分两个阶段（A/B 榜），不提供预测结果，其中：

• 初赛第一阶段 A 榜测试集： 2023 年 2 月 22 日中午 12:00:00— 2023 年 3 月 20 日中午 12:00:00，包括 A 榜阶段食物特征数据（共计 115 种食物）与初赛 A 榜提交样例，用于模型结果验证：

preliminary_a_food.csv
preliminary_a_submit_sample.csv
1
2

• 初赛第二阶段 B 榜测试集： 2023 年 3 月 20 日中午 12:00:00— 2023 年 3 月 22 日中午 12:00:00，包括 B 榜阶段食物特征数据（共计 116 种食物）与初赛 B 榜提交样例，用于模型结果验证：

preliminary_b_food.csv
preliminary_b_submit_sample.csv
1
2

• 初赛第二阶段 B 测试集与初赛第一阶段 A 榜测试集分布与规模相同，将于 B 榜提交开始后在赛事主页提供下载，最终初赛排名以初赛第二阶段 B 榜成绩为准。

1.3 字段说明

1.3.1 疾病特征

累计包含 407 种疾病的 4630 种特征信息，三种不同的特征抽取方式将疾病特征划分为三部分特征集，数据高度稀疏。

1.3.2 食物特征

1.3.3 食物疾病关系

1.4 评测方法

1.5 提交示例

1.6 比赛传送门

比赛传送门

二、项目介绍

2.1 项目意义

在本次食物与疾病关系预测挑战赛中，参赛团队将获得脱敏后的大量数据集。这些数据集包含了各种类型的食物和相应的健康指标，例如血压、胆固醇等等。这些指标可以帮助我们了解不同种类的食物对人体健康产生的影响。在实际应用中，由于数据量巨大且高度稀疏，传统的特征提取方法难以有效地提取出有用信息。因此，在本次比赛中，参赛团队需要进一步挖掘、融合特征并设计模型，以预测食物与疾病的关系。

在这个 Baseline 中，我们分别尝试复杂的特征结合传统的机器学习模型。我们在解决机器学习问题时，一般会遵循以下流程：

2.2 模型介绍

LightGBM（LightGBM: Gradient Boosting of Big Data Applications）是一种基于梯度提升树模型（Gradient Boosting Decision Tree）的轻量级机器学习算法，用于解决大规模数据集的分类、回归和聚类问题。它的核心思想是利用梯度下降来优化模型参数，从而提高模型的预测准确率。LightGBM的主要特点包括以下几个方面：

• 轻量级：LightGBM采用了基于梯度的优化方法，避免了过多的参数调整，从而减少了计算量和内存消耗。
• 高效性：LightGBM的基本思想是利用梯度下降来不断逼近模型的最优参数，从而减少了搜索空间，提高了模型的效率。
• 可解释性：LightGBM采用了可解释的数据预处理方法，即在训练过程中对数据进行归一化、剪枝等处理，从而提高了模型的可解释性和可靠性。
• 易用性：LightGBM提供了灵活的模型定义方式，可以根据实际需求进行定制化开发，同时也提供了丰富的可视化工具，便于用户理解和操作。
• 通用性：LightGBM可以适用于多种机器学习框架和数据存储格式，具有广泛的应用前景。
• 总之，LightGBM是一种高效、可解释、易用的轻量级机器学习算法，适用于大规模数据集的分类、回归和聚类问题。

三、详细方案实现

3.1 数据分析

3.1.1 数据解压缩

!unzip  -d /home/aistudio/data/data200766/  /home/aistudio/data/data200766/初赛A榜测试集.zip
!unzip  -d /home/aistudio/data/data200766/  /home/aistudio/data/data200766/初赛B榜测试集.zip
!unzip  -d /home/aistudio/data/data200766/   /home/aistudio/data/data200766/训练集.zip
1
2
3

Archive:  /home/aistudio/data/data200766/初赛A榜测试集.zip
   creating: /home/aistudio/data/data200766/初赛A榜测试集/
  inflating: /home/aistudio/data/data200766/初赛A榜测试集/preliminary_a_submit_sample.csv  
  inflating: /home/aistudio/data/data200766/初赛A榜测试集/preliminary_a_food.csv  
Archive:  /home/aistudio/data/data200766/初赛B榜测试集.zip
   creating: /home/aistudio/data/data200766/初赛B榜测试集/
  inflating: /home/aistudio/data/data200766/初赛B榜测试集/preliminary_b_submit_sample.csv  
  inflating: /home/aistudio/data/data200766/初赛B榜测试集/preliminary_b_food.csv  
Archive:  /home/aistudio/data/data200766/训练集.zip
   creating: /home/aistudio/data/data200766/训练集/
  inflating: /home/aistudio/data/data200766/训练集/disease_feature3.csv  
  inflating: /home/aistudio/data/data200766/训练集/disease_feature2.csv  
  inflating: /home/aistudio/data/data200766/训练集/disease_feature1.csv  
  inflating: /home/aistudio/data/data200766/训练集/train_answer.csv  
  inflating: /home/aistudio/data/data200766/训练集/train_food.csv  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.1.2 导入相关库

!pip install --upgrade pip
!git clone --recursive https://github.com/Microsoft/LightGBM
!cd LightGBM && rm -rf build && mkdir build && cd build && cmake -DUSE_GPU=1 ../../LightGBM && make -j4 && cd ../python-package && python3 setup.py install --precompile --gpu;


1
2
3
4
5

import pandas as pd
import os
import gc
import lightgbm as lgb
from sklearn.linear_model import SGDRegressor, LinearRegression, Ridge
from sklearn.preprocessing import MinMaxScaler

import math
import numpy as np
from tqdm import tqdm
from sklearn.model_selection import StratifiedKFold, KFold, GroupKFold
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, log_loss
import matplotlib.pyplot as plt
import time
import warnings
warnings.filterwarnings('ignore')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.1.3 加载数据

disease_feature1 = pd.read_csv("/home/aistudio/data/data200766/训练集/disease_feature1.csv")
disease_feature2 = pd.read_csv("/home/aistudio/data/data200766/训练集/disease_feature2.csv")
disease_feature3 = pd.read_csv("/home/aistudio/data/data200766/训练集/disease_feature3.csv")

train_answer = pd.read_csv("/home/aistudio/data/data200766/训练集/train_answer.csv")
train_food = pd.read_csv("/home/aistudio/data/data200766/训练集/train_food.csv")

preliminary_a_food = pd.read_csv("/home/aistudio/data/data200766/初赛B榜测试集/preliminary_b_food.csv")
preliminary_a_submit_sample = pd.read_csv("/home/aistudio/data/data200766/初赛B榜测试集/preliminary_b_submit_sample.csv")
pd.set_option('display.max_columns', None)
1
2
3
4
5
6
7
8
9
10

del preliminary_a_submit_sample['related_prob']
data = pd.concat([train_answer, preliminary_a_submit_sample], axis = 0).reset_index(drop=True)
data.head()
1
2
3

这里直接使用每个变量后的数字进行编码，当然也可以使用labelencoder的方式。

data['food'] = data['food_id'].apply(lambda x : int(x.split('_')[1]))
data['disease'] = data['disease_id'].apply(lambda x : int(x.split('_')[1]))
1
2

food = pd.concat([train_food, preliminary_a_food], axis = 0).reset_index(drop=True)
food.head()
1
2

3.1.4 EDA

# 查看数据缺失情况
pd.set_option('display.max_rows', None)
((food.isnull().sum())/food.shape[0]).sort_values(ascending=False).map(lambda x:"{:.2%}".format(x))

1
2
3
4

#只保留缺失率少于10%的列
food=food[['N_198','N_33','N_211','N_82','N_101','N_42','N_111','N_165','N_177','N_146','N_17','N_113','N_106','N_14','N_74','N_209','N_188','food_id' ]] 
food.head(5)
1
2
3

3.2 数据处理

3.2.1 目标编码

由于本题只有两个离散变量food_id 和disease_id ，而测试集中都是新的foodid

cat_list = ['disease']
def stat(df, df_merge, group_by, agg):
    group = df.groupby(group_by).agg(agg)

    columns = []
    for on, methods in agg.items():
        for method in methods:
            columns.append('{}_{}_{}'.format('_'.join(group_by), on, method))
    group.columns = columns
    group.reset_index(inplace=True)
    df_merge = df_merge.merge(group, on=group_by, how='left')

    del (group)
    gc.collect()
    return df_merge


def statis_feat(df_know, df_unknow,cat_list):
    for f in tqdm(cat_list):
        df_unknow = stat(df_know, df_unknow, [f], {'related': ['mean']})

    return df_unknow


df_train = data[~data['related'].isnull()]
df_train = df_train.reset_index(drop=True)
df_test = data[data['related'].isnull()]

df_stas_feat = None
kf = StratifiedKFold(n_splits=5, random_state=2020, shuffle=True)
for train_index, val_index in kf.split(df_train, df_train['related']):
    df_fold_train = df_train.iloc[train_index]
    df_fold_val = df_train.iloc[val_index]

    df_fold_val = statis_feat(df_fold_train, df_fold_val,cat_list)
    df_stas_feat = pd.concat([df_stas_feat, df_fold_val], axis=0)

    del (df_fold_train)
    del (df_fold_val)
    gc.collect()

df_test = statis_feat(df_train, df_test,cat_list)
data = pd.concat([df_stas_feat, df_test], axis=0)
data = data.reset_index(drop=True)

del (df_stas_feat)
del (df_train)
del (df_test)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

100%|██████████| 1/1 [00:00<00:00,  7.57it/s]
100%|██████████| 1/1 [00:00<00:00,  9.00it/s]
100%|██████████| 1/1 [00:00<00:00,  9.45it/s]
100%|██████████| 1/1 [00:00<00:00,  8.77it/s]
100%|██████████| 1/1 [00:00<00:00,  8.65it/s]
100%|██████████| 1/1 [00:00<00:00,  9.16it/s]
1
2
3
4
5
6

3.2.1 疾病特征处理

使用TruncatedSVD 的方法，对疾病特征进行降维，维度均为128

f_col = [col for col in disease_feature1.columns if 'F' in col]
1

disease_feature_1_ = disease_feature1.copy()
from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer,TfidfTransformer 
from sklearn.decomposition import TruncatedSVD, SparsePCA
disease_feature_1_ = disease_feature_1_.fillna(0)
decom=TruncatedSVD(n_components=128, n_iter = 20, random_state=2023) 

decom_x=decom.fit_transform(disease_feature_1_.iloc[:,1:]) 
decom_feas=pd.DataFrame(decom_x)
decom_feas.columns=['disease1_svd_'+str(i) for i in range(decom_x.shape[1])]
1
2
3
4
5
6
7
8
9

disease_feature1 = disease_feature1[['disease_id']]
for col in decom_feas:
    disease_feature1[col] = decom_feas[col]
1
2
3

f_col = [col for col in disease_feature2.columns if 'F' in col]
1

disease_feature_2_ = disease_feature2.copy()
from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer,TfidfTransformer 
from sklearn.decomposition import TruncatedSVD, SparsePCA
disease_feature_2_ = disease_feature_2_.fillna(0)
decom=TruncatedSVD(n_components=128, n_iter = 20, random_state=2023) 

decom_x=decom.fit_transform(disease_feature_2_.iloc[:,1:]) 
decom_feas=pd.DataFrame(decom_x)
decom_feas.columns=['disease2_svd_'+str(i) for i in range(decom_x.shape[1])]
1
2
3
4
5
6
7
8
9

disease_feature2 = disease_feature2[['disease_id']]
for col in decom_feas:
    disease_feature2[col] = decom_feas[col]
1
2
3

f_col = [col for col in disease_feature3.columns if 'F' in col]
1

disease_feature_3_ = disease_feature3.copy()
from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer,TfidfTransformer 
from sklearn.decomposition import TruncatedSVD, SparsePCA
disease_feature_3_ = disease_feature_3_.fillna(0)
decom=TruncatedSVD(n_components=128, n_iter = 20, random_state=2023) 

decom_x=decom.fit_transform(disease_feature_3_.iloc[:,1:]) 
decom_feas=pd.DataFrame(decom_x)
decom_feas.columns=['disease3_svd_'+str(i) for i in range(decom_x.shape[1])]
1
2
3
4
5
6
7
8
9

disease_feature3 = disease_feature3[['disease_id']]
for col in decom_feas:
    disease_feature3[col] = decom_feas[col]
1
2
3

data = data.merge(food, on = 'food_id', how = 'left')
data = data.merge(disease_feature1, on = 'disease_id', how = 'left')
data = data.merge(disease_feature2, on = 'disease_id', how = 'left')
data = data.merge(disease_feature3, on = 'disease_id', how = 'left')
data.head()
1
2
3
4
5

1

3.2.3 交叉特征

这里按特征重要性选取靠前的部分特征进行交叉

topn = ['N_33', 'N_198', 'N_74','N_188','N_82','N_42','N_111','disease','food']
for i in range(len(topn)):
    for j in range(i + 1, len(topn)):
        data[f'{topn[i]}+{topn[j]}'] = data[topn[i]] + data[topn[j]]
        data[f'{topn[i]}-{topn[j]}'] = data[topn[i]] - data[topn[j]]
        data[f'{topn[i]}*{topn[j]}'] = data[topn[i]] * data[topn[j]]
        data[f'{topn[i]}/{topn[j]}'] = data[topn[i]] / (data[topn[j]]+1e-5)
1
2
3
4
5
6
7

drop_cols = ['disease_id', 'food_id', 'related']
1

3.2.3 特征筛选

去除掉只有单一取值的特征

for f in data.columns:
    if data[f].nunique() < 2:
        drop_cols.append(f)
1
2
3

test_df = data[data["related"].isnull() == True].copy().reset_index(drop=True)
train_df = data[~data["related"].isnull() == True].copy().reset_index(drop=True)
1
2

feature_name = [f for f in train_df.columns if f not in drop_cols]
X_train = train_df[feature_name].reset_index(drop=True)
X_test = test_df[feature_name].reset_index(drop=True)
y = train_df['related'].reset_index(drop=True)
print(len(feature_name))
print(feature_name)
1
2
3
4
5
6

548
['food', 'disease', 'disease_related_mean', 'N_198', 'N_33', 'N_211', 'N_82', 'N_101', 'N_42', 'N_111', 'N_165', 'N_177', 'N_146', 'N_17', 'N_113', 'N_106', 'N_14', 'N_74', 'N_209', 'N_188', 'disease1_svd_0', 'disease1_svd_1', 'disease1_svd_2', 'disease1_svd_3', 'disease1_svd_4', 'disease1_svd_5', 'disease1_svd_6', 'disease1_svd_7', 'disease1_svd_8', 'disease1_svd_9', 'disease1_svd_10', 'disease1_svd_11', 'disease1_svd_12', 'disease1_svd_13', 'disease1_svd_14', 'disease1_svd_15', 'disease1_svd_16', 'disease1_svd_17', 'disease1_svd_18', 'disease1_svd_19', 'disease1_svd_20', 'disease1_svd_21', 'disease1_svd_22', 'disease1_svd_23', 'disease1_svd_24', 'disease1_svd_25', 'disease1_svd_26', 'disease1_svd_27', 'disease1_svd_28', 'disease1_svd_29', 'disease1_svd_30', 'disease1_svd_31', 'disease1_svd_32', 'disease1_svd_33', 'disease1_svd_34', 'disease1_svd_35', 'disease1_svd_36', 'disease1_svd_37', 'disease1_svd_38', 'disease1_svd_39', 'disease1_svd_40', 'disease1_svd_41', 'disease1_svd_42', 'd
1
2

print(test_df.shape)
1

(47212, 551)
1

3.2.3 模型训练

本次仅使用lightgbm模型来训练。

train_pred = {}
test_pred = {}
1
2

seeds = [2]
num_model_seed = 1
oof = np.zeros(X_train.shape[0])
prediction = np.zeros(X_test.shape[0])
feat_imp_df = pd.DataFrame({'feats': feature_name, 'imp': 0})
parameters = {
    'learning_rate': 0.05,
    'boosting_type': 'gbdt',
    'objective': 'binary',
    'metric': 'auc',
    'num_leaves': 63,
    'feature_fraction': 0.8,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'seed': 2022,
    'bagging_seed': 1,
    'feature_fraction_seed': 7,
    'min_data_in_leaf': 20,
    'verbose': -1, 
    'n_jobs':8,
 
   
}
fold = 5
for model_seed in range(num_model_seed):
    print(seeds[model_seed],"--------------------------------------------------------------------------------------------")
    oof_cat = np.zeros(X_train.shape[0])
    prediction_cat = np.zeros(X_test.shape[0])
    skf = StratifiedKFold(n_splits=fold, random_state=seeds[model_seed], shuffle=True)
    for index, (train_index, test_index) in enumerate(skf.split(X_train, y)):
        train_x, test_x, train_y, test_y = X_train[feature_name].iloc[train_index], X_train[feature_name].iloc[test_index], y.iloc[train_index], y.iloc[test_index]
        dtrain = lgb.Dataset(train_x, label=train_y)
        dval = lgb.Dataset(test_x, label=test_y)
        lgb_model = lgb.train(
            parameters,
            dtrain,
            num_boost_round=10000,
            valid_sets=[dval],
            early_stopping_rounds=100,
            verbose_eval=100, )
        oof_cat[test_index] += lgb_model.predict(test_x,num_iteration=lgb_model.best_iteration)
        prediction_cat += lgb_model.predict(X_test,num_iteration=lgb_model.best_iteration) / fold
        feat_imp_df['imp'] += lgb_model.feature_importance()

        del train_x
        del test_x
        del train_y
        del test_y
        del lgb_model
    oof += oof_cat / num_model_seed
    prediction += prediction_cat / num_model_seed
gc.collect()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

3.2.4 结果可视化

train_pred['lgb'] = oof
test_pred['lgb'] = prediction
1
2

print("lgb train auc: ", roc_auc_score(y, train_pred['lgb']))
1

lgb train auc:  0.9778226537246766
1

scores = []; thresholds = []
best_score = 0; best_threshold = 0

for threshold in np.arange(0.1,0.9,0.01):
    print(f'{threshold:.02f}, ',end='')
    preds = (train_pred['lgb'].reshape((-1)) > threshold).astype('int')
    m = f1_score(y.values.reshape((-1)), preds, average='binary')   
    scores.append(m)
    thresholds.append(threshold)
    if m>best_score:
        best_score = m
        best_threshold = threshold
1
2
3
4
5
6
7
8
9
10
11
12

0.10, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.30, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.40, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.60, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69, 0.70, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79, 0.80, 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89, 
1

import matplotlib.pyplot as plt

# PLOT THRESHOLD VS. F1_SCORE
plt.figure(figsize=(20,5))
plt.plot(thresholds,scores,'-o',color='blue')
plt.scatter([best_threshold], [best_score], color='blue', s=300, alpha=1)
plt.xlabel('Threshold',size=14)
plt.ylabel('Validation F1 Score',size=14)
plt.title(f'Threshold vs. F1_Score with Best F1_Score = {best_score:.3f} at Best Threshold = {best_threshold:.3}',size=18)
plt.show()
1
2
3
4
5
6
7
8
9
10

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JhOW2ktx-1682508721966)(main_files/main_77_0.png)]

auc = roc_auc_score(y, train_pred['lgb'])
f1 = best_score
print((auc + f1) / 2)
1
2
3

0.8939347040505519
1

`

0.8939347040505519
1

3.2.5 生成提交结果

控制1的个数为4100个左右，最终结果：

# label=[1 if x >= 0.265+0.235 else 0 for x in prediction+0.235]
# np.sum(label)

label=[1 if x >= 0.26+0.24 else 0 for x in prediction+0.25]
np.sum(label)
1
2
3
4
5

4032
1

preliminary_a_submit_sample['related_prob'] = prediction+0.25
1

preliminary_a_submit_sample.to_csv('submit.csv', index=False)
1

四、项目总结

4.1 提交结果

4.2 优化思路

1. 由于foodid只有训练集有，那么是否可以使用food侧的特征，做相似度模型，例如共现矩阵、tfidf、embedding等。

2. 目标编码做了之后，线下会涨很多但是线上长得比较少，还是过拟合比较严重，是否可以考虑根据疾病特征做聚类，然后减轻这种情况。同理food侧特征也可以做聚类，用来解决测试集都是训练集未曾出现过的id的问题。

3. 交叉特征里面，对于food侧只取了一部分，是否可以多取一点（进一步上述base可以通过筛选food特征提升至7976的分数，但是会很抖）。

4. 特征筛选的地方，并没有剔除缺失率高的特征，也没有根据对抗验证进行筛选，或许可以进行尝试。

5. 模型训练的参数，学习率太低，叶子节点数太高，导致模型过拟合比较严重，可以考虑调参（可以上分）。

6. 目前仅使用了lightgbm模型，可以考虑xgboost，catboost模型，进行模型的集成（xgb貌似还不错，需要祖传参数）。

7. 上述base是1的个数为4100个，可以调整不同的个数来测试，亲测不同的特征组合哪怕只是添加一个，最优的1的个数都是不同的。

8. svd的维度是可以调整的，不一定每个都是一样的。以及还可以使用pca的方法，不过需要进行归一化。

4.3 作者介绍

本人是AI达人特训营第三期项目中的一名学员，非常有幸能与大家分享自己的所思所想。

作者：范远展 指导导师：黄灿桦

此文章为搬运
原项目链接