Task从零入门AI for Science（AI+化学）

 最新分数：0.3846

 比赛链接：上海科学智能研究院 (sais.com.cn)

一、比赛任务

       本次比赛提供在药物合成中常见的多种催化反应实验数据，其中包括反应的底物、包括催化剂在内的反应添加剂、反应溶剂以及反应产物，期待选手通过分析反应数据，利用机器学习、深度学习算法或者大语言模型，建立产率预测模型，从而辅助未知新反应的反应条件筛选。

任务：构建一个能够准确预测碳氮成键反应产率的预测模型

通过对反应中所包含的反应底物、添加剂、溶剂以及产物进行合理的特征化，运用机器学习模型或者深度学习模型拟合预测反应的产率。或者利用训练集数据对开源大语言模型进行微调以预测反应的产率

部分数据如下所示：

二、Task1:baseline代码

 1）导入基本包

<code>import pickle # 导入pickle模块，用于序列化和反序列化Python对象

import pandas as pd # 导入pandas库，用于数据处理和分析

from tqdm import tqdm # 从tqdm库导入tqdm，用于显示进度条

from sklearn.ensemble import RandomForestRegressor # 从sklearn库导入RandomForestRegressor，用于随机森林回归模型

from rdkit.Chem import rdMolDescriptors # 从rdkit.Chem导入rdMolDescriptors，用于计算分子描述符

from rdkit import RDLogger, Chem # 从rdkit导入RDLogger和Chem，用于处理分子和日志记录

import numpy as np # 导入numpy库，用于科学计算

RDLogger.DisableLog('rdApp.*') # 禁用RDKit的日志记录，避免不必要的输出

2）将SMILES字符串列表转换为分子指纹向量的列表

def mfgen(mol,nBits=2048, radius=2):

'''

Parameters

----------

mol : mol

RDKit mol object.

nBits : int

Number of bits for the fingerprint.

radius : int

Radius of the Morgan fingerprint.

Returns

-------

mf_desc_map : ndarray

ndarray of molecular fingerprint descriptors.

'''

fp = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol,radius=radius,nBits=nBits)

return np.array(list(map(eval,list(fp.ToBitString()))))

def vec_cpd_lst(smi_lst):

smi_set = list(set(smi_lst))

smi_vec_map = {}

for smi in tqdm(smi_set):

mol = Chem.MolFromSmiles(smi)

smi_vec_map[smi] = mfgen(mol)

smi_vec_map[''] = np.zeros(2048)

vec_lst = [smi_vec_map[smi] for smi in smi_lst]

return np.array(vec_lst)

解释：mfgen函数生成一个分子的Morgan指纹。它接受一个RDKit的分子对象、指纹的位数（默认为2048位）和半径（默认为2），然后计算并返回该分子的指纹描述符，作为一个numpy数组

vec_cpd_lst函数将SMILES字符串列表转换为分子指纹向量的列表。它先创建一个包含唯一SMILES字符串的集合，然后计算每个SMILES对应的指纹向量，并将其存储在字典中。最后，它将输入列表中的每个SMILES转换为其指纹向量，并以numpy数组的形式返回这些向量。

3）导入训练集与测试集

dataset_dir = './dataset' # Change this to your dataset directory

train_df = pd.read_csv(f'{dataset_dir}/round1_train_data.csv')

test_df = pd.read_csv(f'{dataset_dir}/round1_test_data.csv')

print(f'Training set size: {len(train_df)}, test set size: {len(test_df)}')

Training set size: 23538, test set size: 2616

4）处理训练集和测试集

train_rct1_smi = train_df['Reactant1'].to_list()

train_rct2_smi = train_df['Reactant2'].to_list()

train_add_smi = train_df['Additive'].to_list()

train_sol_smi = train_df['Solvent'].to_list()

train_rct1_fp = vec_cpd_lst(train_rct1_smi)

train_rct2_fp = vec_cpd_lst(train_rct2_smi)

train_add_fp = vec_cpd_lst(train_add_smi)

train_sol_fp = vec_cpd_lst(train_sol_smi)

train_x = np.concatenate([train_rct1_fp,train_rct2_fp,train_add_fp,train_sol_fp],axis=1)

train_y = train_df['Yield'].to_numpy()

test_rct1_smi = test_df['Reactant1'].to_list()

test_rct2_smi = test_df['Reactant2'].to_list()

test_add_smi = test_df['Additive'].to_list()

test_sol_smi = test_df['Solvent'].to_list()

test_rct1_fp = vec_cpd_lst(test_rct1_smi)

test_rct2_fp = vec_cpd_lst(test_rct2_smi)

test_add_fp = vec_cpd_lst(test_add_smi)

test_sol_fp = vec_cpd_lst(test_sol_smi)

test_x = np.concatenate([test_rct1_fp,test_rct2_fp,test_add_fp,test_sol_fp],axis=1)

100%|██████████████████████████████████████████████████████████████████████████████| 6081/6081 [05:16<00:00, 19.24it/s]

100%|██████████████████████████████████████████████████████████████████████████████| 8763/8763 [07:22<00:00, 19.79it/s]

100%|██████████████████████████████████████████████████████████████████████████████| 1284/1284 [01:18<00:00, 16.26it/s]

100%|████████████████████████████████████████████████████████████████████████████████| 432/432 [00:29<00:00, 14.48it/s]

100%|██████████████████████████████████████████████████████████████████████████████| 1257/1257 [00:54<00:00, 23.21it/s]

100%|██████████████████████████████████████████████████████████████████████████████| 1743/1743 [00:46<00:00, 37.15it/s]

100%|████████████████████████████████████████████████████████████████████████████████| 404/404 [00:14<00:00, 27.65it/s]

100%|████████████████████████████████████████████████████████████████████████████████| 143/143 [00:09<00:00, 15.24it/s]

使用vec_cpd_lst函数将测试数据集中每种反应物、添加剂和溶剂的SMILES字符串转换为分子指纹表示。这将为每个SMILES字符串生成一个指纹向量，并将所有这些指纹向量存储在相应的变量中。

将测试数据集中反应物1、反应物2、添加剂和溶剂的分子指纹向量在列（特征）方向上拼接，形成一个大的特征矩阵test_x，其中每行对应一个测试样本，每列对应一个特征（分子指纹位）。

5)模型的训练及保存

# Model fitting

model = RandomForestRegressor(n_estimators=100,max_depth=10,min_samples_split=2,min_samples_leaf=1,n_jobs=-1)

model.fit(train_x,train_y)

# Saving model to file

with open('./random_forest_model.pkl', 'wb') as file:

pickle.dump(model, file)

# Load model from file

with open('random_forest_model.pkl', 'rb') as file:

loaded_model = pickle.load(file)

# Inference

test_pred = loaded_model.predict(test_x)

dataline中使用了随机森林回归模型，以下是基本介绍：

基本概念

集成学习：随机森林是一种集成学习方法，它通过结合多个学习器（决策树）来改善模型的预测性能和稳定性。决策树：决策树是一种树状结构的模型，用于将数据分割成更小的部分，从而做出预测。每个节点表示对某个特征的判断，叶子节点表示预测结果。随机性：随机森林通过引入随机性来增强模型的泛化能力。这包括两方面：

样本随机性：通过对训练数据进行有放回的随机抽样（称为Bootstrap抽样）来训练每棵树。特征随机性：在每个节点分裂时，只考虑一部分随机选择的特征，而不是全部特征。

工作原理

构建多个决策树：通过对训练数据进行Bootstrap抽样，构建多个决策树。每棵树在不同的样本上训练，同时在每个节点的分裂过程中只考虑部分特征。集成决策：对于回归任务，随机森林模型通过对所有树的预测结果取平均值来进行最终的预测。这个过程减少了单个树可能出现的过拟合现象，从而提高了整体模型的稳定性和准确性。

优点

高准确性：通过结合多个决策树，随机森林通常比单个决策树具有更高的准确性。抗过拟合：由于随机森林在训练过程中引入了随机性，它对训练数据的过拟合风险较低。处理高维数据：随机森林能够处理高维数据集，并且不需要对数据进行标准化或归一化处理。特征重要性：随机森林可以评估每个特征的重要性，有助于进行特征选择。

缺点

训练时间长：由于需要构建多个决策树，随机森林的训练时间可能较长，尤其是在数据量大或特征多的情况下。预测速度慢：由于需要结合多个决策树的结果，随机森林的预测速度相对较慢。

6）保存结果

ans_str_lst = ['rxnid,Yield']

for idx,y in enumerate(test_pred):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open('./submit.txt','w') as fw:

fw.writelines('\n'.join(ans_str_lst))

运行后会生成一个文件submit.txt ，然后在提交平台提交就可以得到分数啦！

这里我得到了0.1996分，哈哈好像大家的分数都不太一样，有分数还是挺好玩的。

​

7)完整代码展示：

<code>import pickle

import pandas as pd

from tqdm import tqdm

from sklearn.ensemble import RandomForestRegressor

from rdkit.Chem import rdMolDescriptors

from rdkit import RDLogger,Chem

import numpy as np

RDLogger.DisableLog('rdApp.*')

def mfgen(mol,nBits=2048, radius=2):

'''

Parameters

----------

mol : mol

RDKit mol object.

nBits : int

Number of bits for the fingerprint.

radius : int

Radius of the Morgan fingerprint.

Returns

-------

mf_desc_map : ndarray

ndarray of molecular fingerprint descriptors.

'''

fp = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol,radius=radius,nBits=nBits)

return np.array(list(map(eval,list(fp.ToBitString()))))

def vec_cpd_lst(smi_lst):

smi_set = list(set(smi_lst))

smi_vec_map = {}

for smi in tqdm(smi_set):

mol = Chem.MolFromSmiles(smi)

smi_vec_map[smi] = mfgen(mol)

smi_vec_map[''] = np.zeros(2048)

vec_lst = [smi_vec_map[smi] for smi in smi_lst]

return np.array(vec_lst)

## Vectorization

dataset_dir = './dataset' # Change this to your dataset directory

train_df = pd.read_csv(f'{dataset_dir}/round1_train_data.csv')

test_df = pd.read_csv(f'{dataset_dir}/round1_test_data.csv')

print(f'Training set size: {len(train_df)}, test set size: {len(test_df)}')

train_rct1_smi = train_df['Reactant1'].to_list()

train_rct2_smi = train_df['Reactant2'].to_list()

train_add_smi = train_df['Additive'].to_list()

train_sol_smi = train_df['Solvent'].to_list()

train_rct1_fp = vec_cpd_lst(train_rct1_smi)

train_rct2_fp = vec_cpd_lst(train_rct2_smi)

train_add_fp = vec_cpd_lst(train_add_smi)

train_sol_fp = vec_cpd_lst(train_sol_smi)

train_x = np.concatenate([train_rct1_fp,train_rct2_fp,train_add_fp,train_sol_fp],axis=1)

train_y = train_df['Yield'].to_numpy()

test_rct1_smi = test_df['Reactant1'].to_list()

test_rct2_smi = test_df['Reactant2'].to_list()

test_add_smi = test_df['Additive'].to_list()

test_sol_smi = test_df['Solvent'].to_list()

test_rct1_fp = vec_cpd_lst(test_rct1_smi)

test_rct2_fp = vec_cpd_lst(test_rct2_smi)

test_add_fp = vec_cpd_lst(test_add_smi)

test_sol_fp = vec_cpd_lst(test_sol_smi)

test_x = np.concatenate([test_rct1_fp,test_rct2_fp,test_add_fp,test_sol_fp],axis=1)

## Model fitting and saving

# Model fitting

model = RandomForestRegressor(n_estimators=100,max_depth=10,min_samples_split=2,min_samples_leaf=1,n_jobs=-1)

model.fit(train_x,train_y)

# Saving model to file

with open('./random_forest_model.pkl', 'wb') as file:

pickle.dump(model, file)

# Load model from file

with open('random_forest_model.pkl', 'rb') as file:

loaded_model = pickle.load(file)

# Inference

test_pred = loaded_model.predict(test_x)

## Answer generation

ans_str_lst = ['rxnid,Yield']

for idx,y in enumerate(test_pred):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open('./submit.txt','w') as fw:

fw.writelines('\n'.join(ans_str_lst))

我又用了lightgbm模型尝试训练了一下，分数提高了一些，参数改一改可能会更高！可惜没有提交次数了

import pickle

import pandas as pd

from tqdm import tqdm

from rdkit.Chem import rdMolDescriptors

from rdkit import RDLogger, Chem

import numpy as np

import lightgbm as lgb

RDLogger.DisableLog('rdApp.*')

def mfgen(mol, nBits=2048, radius=2):

'''

Parameters

----------

mol : mol

RDKit mol object.

nBits : int

Number of bits for the fingerprint.

radius : int

Radius of the Morgan fingerprint.

Returns

-------

mf_desc_map : ndarray

ndarray of molecular fingerprint descriptors.

'''

fp = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol, radius=radius, nBits=nBits)

return np.array(list(map(int, list(fp.ToBitString()))))

def vec_cpd_lst(smi_lst):

smi_set = list(set(smi_lst))

smi_vec_map = {}

for smi in tqdm(smi_set):

mol = Chem.MolFromSmiles(smi)

smi_vec_map[smi] = mfgen(mol)

smi_vec_map[''] = np.zeros(2048)

vec_lst = [smi_vec_map[smi] for smi in smi_lst]

return np.array(vec_lst)

## 向量化

dataset_dir = './dataset' # 更改为你的数据集目录

train_df = pd.read_csv(f'{dataset_dir}/round1_train_data.csv')

test_df = pd.read_csv(f'{dataset_dir}/round1_test_data.csv')

print(f'训练集大小: {len(train_df)}, 测试集大小: {len(test_df)}')

train_rct1_smi = train_df['Reactant1'].to_list()

train_rct2_smi = train_df['Reactant2'].to_list()

train_add_smi = train_df['Additive'].to_list()

train_sol_smi = train_df['Solvent'].to_list()

train_rct1_fp = vec_cpd_lst(train_rct1_smi)

train_rct2_fp = vec_cpd_lst(train_rct2_smi)

train_add_fp = vec_cpd_lst(train_add_smi)

train_sol_fp = vec_cpd_lst(train_sol_smi)

train_x = np.concatenate([train_rct1_fp, train_rct2_fp, train_add_fp, train_sol_fp], axis=1)

train_y = train_df['Yield'].to_numpy()

test_rct1_smi = test_df['Reactant1'].to_list()

test_rct2_smi = test_df['Reactant2'].to_list()

test_add_smi = test_df['Additive'].to_list()

test_sol_smi = test_df['Solvent'].to_list()

test_rct1_fp = vec_cpd_lst(test_rct1_smi)

test_rct2_fp = vec_cpd_lst(test_rct2_smi)

test_add_fp = vec_cpd_lst(test_add_smi)

test_sol_fp = vec_cpd_lst(test_sol_smi)

test_x = np.concatenate([test_rct1_fp, test_rct2_fp, test_add_fp, test_sol_fp], axis=1)

## 模型拟合与保存

# 模型拟合

model = lgb.LGBMRegressor(n_estimators=100, max_depth=10, learning_rate=0.1, num_leaves=31)

model.fit(train_x, train_y)

# 保存模型到文件

with open('./lightgbm_model.pkl', 'wb') as file:

pickle.dump(model, file)

# 从文件加载模型

with open('lightgbm_model.pkl', 'rb') as file:

loaded_model = pickle.load(file)

# 推理

test_pred = loaded_model.predict(test_x)

## 生成答案

ans_str_lst = ['rxnid,Yield']

for idx, y in enumerate(test_pred):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open('./submit.txt', 'w') as fw:

fw.writelines('\n'.join(ans_str_lst))

​

三、Task2：使用RNN网络建模SMILES序列

1）简单介绍RNN模型：

1.RNN的架构示意图：

其中，每一层相当于做了一次线性变换：

以下是RNN的一些主要特点：

循环结构：允许信息在时间上被传播，即同一组权重可以在序列的不同位置重复使用。隐藏状态：代表了网络的记忆，可以捕获序列中先前元素的信息。序列输入和输出：RNN可以处理可变长度的输入序列，并产生可变长度的输出序列。

但是RNN也有缺点：如果序列太长，那么两个相距比较远的字符之间的联系需要通过多个隐藏向量。这就像人和人之间传话一样，传递的人多了，很容易导致信息的损失或者扭曲。因此，它对长序列的记忆能力较弱。

同时，RNN需要一层一层地传递，所以并行能力差，比较容易出现梯度消失或梯度爆炸问题。

2）导入基本包，定义RNN模型

<code>import re

import time

import pandas as pd

from typing import List, Tuple

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import Dataset, DataLoader, Subset

# 定义RNN模型

class RNNModel(nn.Module):

def __init__(self, num_embed, input_size, hidden_size, output_size, num_layers, dropout, device):

super(RNNModel, self).__init__()

self.embed = nn.Embedding(num_embed, input_size)

self.rnn = nn.RNN(input_size, hidden_size, num_layers=num_layers,

batch_first=True, dropout=dropout, bidirectional=True)

self.fc = nn.Sequential(nn.Linear(2 * num_layers * hidden_size, output_size),

nn.Sigmoid(),

nn.Linear(output_size, 1),

nn.Sigmoid())

def forward(self, x):

# x : [bs, seq_len]

x = self.embed(x)

# x : [bs, seq_len, input_size]

_, hn = self.rnn(x) # hn : [2*num_layers, bs, h_dim]

hn = hn.transpose(0,1)

z = hn.reshape(hn.shape[0], -1) # z shape: [bs, 2*num_layers*h_dim]

output = self.fc(z).squeeze(-1) # output shape: [bs, 1]

return output

3）定义数据处理函数，以及tokenizer

 tokenizer，鉴于SMILES的特性，这里需要自己定义tokenizer和vocab

 这里直接将smiles str按字符拆分，并替换为词汇表中的序号

# 数据处理部分

class Smiles_tokenizer():

def __init__(self, pad_token, regex, vocab_file, max_length):

self.pad_token = pad_token

self.regex = regex

self.vocab_file = vocab_file

self.max_length = max_length

with open(self.vocab_file, "r") as f:

lines = f.readlines()

lines = [line.strip("\n") for line in lines]

vocab_dic = {}

for index, token in enumerate(lines):

vocab_dic[token] = index

self.vocab_dic = vocab_dic

def _regex_match(self, smiles):

regex_string = r"(" + self.regex + r"|"

regex_string += r".)"

prog = re.compile(regex_string)

tokenised = []

for smi in smiles:

tokens = prog.findall(smi)

if len(tokens) > self.max_length:

tokens = tokens[:self.max_length]

tokenised.append(tokens) # 返回一个所有的字符串列表

return tokenised

def tokenize(self, smiles):

tokens = self._regex_match(smiles)

# 添加上表示开始和结束的token：<cls>, <end>

tokens = [["<CLS>"] + token + ["<SEP>"] for token in tokens]

tokens = self._pad_seqs(tokens, self.pad_token)

token_idx = self._pad_token_to_idx(tokens)

return tokens, token_idx

def _pad_seqs(self, seqs, pad_token):

pad_length = max([len(seq) for seq in seqs])

padded = [seq + ([pad_token] * (pad_length - len(seq))) for seq in seqs]

return padded

def _pad_token_to_idx(self, tokens):

idx_list = []

for token in tokens:

tokens_idx = []

for i in token:

if i in self.vocab_dic.keys():

tokens_idx.append(self.vocab_dic[i])

else:

self.vocab_dic[i] = max(self.vocab_dic.values()) + 1

tokens_idx.append(self.vocab_dic[i])

idx_list.append(tokens_idx)

return idx_list

4)读取并处理数据

import matplotlib.pyplot as plt

# 读数据并处理

def read_data(file_path, train=True):

df = pd.read_csv(file_path)

reactant1 = df["Reactant1"].tolist()

reactant2 = df["Reactant2"].tolist()

product = df["Product"].tolist()

additive = df["Additive"].tolist()

solvent = df["Solvent"].tolist()

if train:

react_yield = df["Yield"].tolist()

else:

react_yield = [0 for i in range(len(reactant1))]

# 将reactant拼到一起，之间用.分开。product也拼到一起，用>分开

input_data_list = []

for react1, react2, prod, addi, sol in zip(reactant1, reactant2, product, additive, solvent):

input_info = ".".join([react1, react2])

input_info = ">".join([input_info, prod])

input_data_list.append(input_info)

output = [(react, y) for react, y in zip(input_data_list, react_yield)]

# 统计seq length，序列的长度是一个重要的参考，可以使用下面的代码统计查看以下序列长度的分布

seq_length = [len(i[0]) for i in output]

seq_length_400 = [len(i[0]) for i in output if len(i[0])>200]

print(len(seq_length_400) / len(seq_length))

seq_length.sort(reverse=True)

plt.plot(range(len(seq_length)), seq_length)

plt.title("templates frequence")

plt.show()

return output

class ReactionDataset(Dataset):

def __init__(self, data: List[Tuple[List[str], float]]):

self.data = data

def __len__(self):

return len(self.data)

def __getitem__(self, idx):

return self.data[idx]

def collate_fn(batch):

REGEX = r"\[[^\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\(|\)|\.|=|#|-|\+|\\\\|\/|:|~|@|\?|>|\*|\$|\%[0-9]{2}|[0-9]"

tokenizer = Smiles_tokenizer("<PAD>", REGEX, "../vocab_full.txt", max_length=300)

smi_list = []

yield_list = []

for i in batch:

smi_list.append(i[0])

yield_list.append(i[1])

tokenizer_batch = torch.tensor(tokenizer.tokenize(smi_list)[1])

yield_list = torch.tensor(yield_list)

return tokenizer_batch, yield_list

5）生成结果文件

<code># 生成结果文件

def predicit_and_make_submit_file(model_file, output_file):

NUM_EMBED = 294

INPUT_SIZE = 300

HIDDEN_SIZE = 512

OUTPUT_SIZE = 512

NUM_LAYERS = 10

DROPOUT = 0.2

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

test_data = read_data('C:/Users/15871/Desktop/yield/round1_test_data.csv', train=False)

test_dataset = ReactionDataset(test_data)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, collate_fn=collate_fn)

model = RNNModel(NUM_EMBED, INPUT_SIZE, HIDDEN_SIZE, OUTPUT_SIZE, NUM_LAYERS, DROPOUT, device).to(device)

# 加载最佳模型

model.load_state_dict(torch.load(model_file))

model.eval()

output_list = []

for i, (src, y) in enumerate(test_loader):

src, y = src.to(device), y.to(device)

with torch.no_grad():

output = model(src)

output_list += output.detach().tolist()

ans_str_lst = ['rxnid,Yield']

for idx,y in enumerate(output_list):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open(output_file,'w') as fw:

fw.writelines('\n'.join(ans_str_lst))

print("done!!!")

predicit_and_make_submit_file("../model/RNN.pth",

"../output/RNN_submit.txt")

 整段代码跑了一个多小时，返回的分数还更低了，但还是能比较好的理解RNN模型的建立与使用

四、继续尝试使用lightgbm模型预测

Task1学习的时候我就尝试过了lightgbm模型，效果还不错，通过参数的修改，因该还能有更好的预测效果。

1）lightgbm模型调参

以下是部分代码展示：

<code>clf_name == "lgb":

train_matrix = lgb.Dataset(trn_x, label=trn_y)

valid_matrix = lgb.Dataset(val_x, label=val_y)

params = {

'boosting_type': 'gbdt',

'objective': 'regression',

'metric': 'mse',

'max_depth' : 10,

'min_child_weight': 1.0,

'num_leaves': ,

'lambda_l2': 12,

'feature_fraction': 0.8,

'bagging_fraction': 0.8,

'bagging_freq': 1,

'learning_rate': 0.01,

'seed': 2024,

'nthread' : 16,

'verbose' : -1,

model = lgb.train(params, train_matrix, 5000, valid_sets=[train_matrix, valid_matrix],

categorical_feature=[], callbacks=[lgb.early_stopping(500), lgb.log_evaluation(500)])

val_pred = model.predict(val_x, num_iteration=model.best_iteration)

test_pred = model.predict(test_x, num_iteration=model.best_iteration)

oof[valid_index] = val_pred

test_predict += test_pred / folds

cv_score = mean_squared_error(val_y, val_pred)

cv_scores.append(cv_score)

return oof, test_predict

# 使用交叉验证训练模型并预测

oof, test_pred = cv_model(lgb, train_x, train_y, test_x, "lgb")

# 生成提交答案

ans_str_lst = ['rxnid,Yield']

for idx, y in enumerate(test_pred):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open('./submit.txt', 'w') as fw:

fw.writelines('\n'.join(ans_str_lst))

2）K折验证

简单介绍

K折交叉验证（K-fold cross-validation）是一种常用的模型评估技术，用于评估机器学习模型在训练数据上的性能。它将原始数据集分成K个子集，称为折（fold）。然后，模型在K个不同的训练集上进行K次训练和验证，在每次训练中，其中一个折被作为验证集，而剩下的K-1个折被用作训练集。这样就产生了K个模型和对应的K个验证分数。

K折交叉验证的步骤如下：

1、将原始数据集分成K个子集。

2、对于每个子集i，将其作为验证集，其余的K-1个子集作为训练集。

3、训练模型，并在验证集上进行评估，记录评估指标（如准确率、精确度、召回率等）。

4、重复步骤2和3，直到每个子集都充当一次验证集，从而产生了K个评估指标。

5、对K个评估指标取平均值作为最终的模型性能评估指标

代码实现

在模型调参后增加K折验证，分数再进一步

<code>#K折验证+lightgbm模型调参

def cv_model(clf, train_x, train_y, test_x, clf_name, seed=2024):

folds = 10

kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

oof = np.zeros(train_x.shape[0])

test_predict = np.zeros(test_x.shape[0])

cv_scores = []

for i, (train_index, valid_index) in enumerate(kf.split(train_x, train_y)):

print('************************************ {} ************************************'.format(str(i+1)))

trn_x, trn_y, val_x, val_y = train_x[train_index], train_y[train_index], train_x[valid_index], train_y[valid_index]

if clf_name == "lgb":

train_matrix = lgb.Dataset(trn_x, label=trn_y)

valid_matrix = lgb.Dataset(val_x, label=val_y)

params = {

'boosting_type': 'gbdt',

'objective': 'regression',

'metric': 'mse',

'max_depth' : 10,

'min_child_weight': 1.0,

'num_leaves': ,

'lambda_l2': 12,

'feature_fraction': 0.8,

'bagging_fraction': 0.8,

'bagging_freq': 1,

'learning_rate': 0.01,

'seed': 2024,

'nthread' : 16,

'verbose' : -1,

}

model = lgb.train(params, train_matrix, 50000, valid_sets=[train_matrix, valid_matrix],

categorical_feature=[], callbacks=[lgb.early_stopping(500), lgb.log_evaluation(500)])

val_pred = model.predict(val_x, num_iteration=model.best_iteration)

test_pred = model.predict(test_x, num_iteration=model.best_iteration)

oof[valid_index] = val_pred

test_predict += test_pred / folds

cv_score = mean_squared_error(val_y, val_pred)

cv_scores.append(cv_score)

print(f"平均验证集MSE: {np.mean(cv_scores):.4f}, 标准差: {np.std(cv_scores):.4f}")

return oof, test_predict

# 使用交叉验证训练模型并预测

oof, test_pred = cv_model(lgb, train_x, train_y, test_x, "lgb")

# 生成提交答案

ans_str_lst = ['rxnid,Yield']

for idx, y in enumerate(test_pred):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open('./submit.txt', 'w') as fw:

fw.writelines('\n'.join(ans_str_lst))

3）网格搜索，交叉验证

网格搜索和交叉验证是机器学习中常用的模型评估和参数调优技术：

网格搜索（Grid Search）是一种穷举法，它遍历预先指定的一系列参数组合（形成一个网格）。对于每个参数组合，网格搜索都会训练一个模型并计算其性能指标（如准确率、AUC等）。最终，网格搜索会返回最佳参数组合，即在给定指标上表现最优的那个。网格搜索适合于参数较少的情况，但如果参数空间很大，可能会消耗大量时间和资源。

交叉验证（Cross-validation）则是为了评估模型性能而设计的一种方法。它将原始数据划分为K个互不重叠的子集（称为折），然后进行多次训练和测试过程。每次选取其中一个子集作为验证集，其余作为训练集，重复这个过程直到每个子集都被用作验证集一次。最后，将所有验证结果平均得到模型的泛化能力估计。交叉验证有助于避免因随机划分数据而导致的偏差，特别是当数据集较小的时候，能更好地估计模型的真实性能。

代码实现

<code># 设置网格搜索的参数空间

param_grid = {

'feature_fraction': [0.6,0.8,1.0],

'bagging_fraction':[0.6,0.8,1.0],

'bagging_freq': [4,6,8],

'learning_rate': [0.01,0.05,0.10],

}

# 执行网格搜索

lgb_estimator = lgb.LGBMRegressor(boosting_type='gbdt', objective='regression', metric='mse', seed=2024, nthread=16, verbose=-1)code>

grid_search = GridSearchCV(estimator=lgb_estimator, param_grid=param_grid, scoring='neg_mean_squared_error', cv=3)code>

grid_search.fit(train_x, train_y)

print("Best Parameters:", grid_search.best_params_)

print("Best CV Score:", -grid_search.best_score_)

# 使用最佳参数训练模型并保存

best_params = grid_search.best_params_

model = lgb.LGBMRegressor(**best_params, boosting_type='gbdt', objective='regression', metric='mse', seed=2024, nthread=16, verbose=-1)code>

model.fit(train_x, train_y)

# 使用模型进行预测

test_pred = loaded_model.predict(test_x)

# 生成提交答案

ans_str_lst = ['rxnid,Yield']

for idx, y in enumerate(test_pred):

ans_str_lst.append(f'test{idx+1},{y:.4f}')

with open('./submit.txt', 'w') as fw:

fw.writelines('\n'.join(ans_str_lst))

Best Parameters: {'bagging_fraction': 0.8, 'bagging_freq': 8, 'feature_fraction': 0.6, 'learning_rate': 0.1}

Best CV Score: 0.048864451091337045

4）尝试使用贝叶斯搜索