特征工程技巧—Bert

前段时间在参加比赛,发现有一些比赛上公开的代码,其中的数据预处理步骤值得我们参考。

平常我们见到的都是数据预处理,现在我们来讲一下特征工程跟数据预处理的区别。

  1. 数据预处理是指对原始数据进行清洗、转换、缩放等操作,以便为后续的建模或分析任务做准备。这包括处理缺失值、异常值、重复值,以及对数据进行归一化、标准化等操作,使数据适合模型处理。

  2. 特征工程则更侧重于从原始数据中提取、构建或转换特征,以提高模型的性能。这包括特征选择、特征抽取、特征转换等过程。在特征工程中,可以创建新的特征、组合现有特征、进行降维等操作,以便使模型更好地捕捉数据中的模式和关系

 训练集

测试集

注:这个代码也可以用在自己的工程项目中,还是比较不错的!也是目前在Kaggle社区里公开代码分数比较高的一个单模型。

1、安装库

!pip install rdkit
!pip install -U /kaggle/input/lightning-2-2-1/lightning-2.2.1-py3-none-any.whl

RDKit:是一个用于化学信息学和药物发现的开源软件包。它提供了丰富的化学信息处理功能和工具,用于分子建模、药物设计、化合物筛选等领域。

PyTorch Lightning:于简化和加速深度学习项目开发的库。它构建在PyTorch之上,提供了高级抽象和预定义模板,使得构建、训练和调试神经网络模型变得更加简单和高效。

2、导入所需的Python库和模块

from pathlib import Path
import numpy as np
import polars as pl
from sklearn.model_selection import train_test_split
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchmetrics import AveragePrecision
import lightning as L
from lightning.pytorch.callbacks import (EarlyStopping,ModelCheckpoint,TQDMProgressBar,
)
from transformers import AutoConfig, AutoTokenizer, AutoModel, DataCollatorWithPadding
import datasets
from rdkit import Chem

 导入数据处理、深度学习、Lightning等相关模块

3、配置超参数 

DEBUG = False
NORMALIZE = True
N_ROWS = 180_000_000
assert N_ROWS is None or N_ROWS % 3 == 0
if DEBUG:N_SAMPLES = 10_000
else:N_SAMPLES = 2_000_000
PROTEIN_NAMES = ["BRD4", "HSA", "sEH"]
data_dir = Path("/kaggle/input/leash-BELKA")
model_name = "DeepChem/ChemBERTa-10M-MTR"
batch_size = 256
trainer_params = {"max_epochs": 5,"enable_progress_bar": True,"accelerator": "auto","precision": "16-mixed","gradient_clip_val": None,"accumulate_grad_batches": 1,"devices": [0],
}
  1. DEBUG = False:设置调试标志,表示是否处于调试模式。

  2. NORMALIZE = True:设置规范化标志,表示是否对化学分子的SMILES表示进行规范化处理。

  3. N_ROWS = 180_000_000:设置处理的最大行数,这里指定了处理的数据集的行数上限。

  4. assert N_ROWS is None or N_ROWS % 3 == 0:使用assert语句确保数据行数是3的倍数,因为后面的代码根据这个假设进行数据处理。

  5. if DEBUG::检查是否处于调试模式。

  6. N_SAMPLES = 10_000 if DEBUG else 2_000_000:根据是否处于调试模式,设置样本数目。

  7. PROTEIN_NAMES = ["BRD4", "HSA", "sEH"]:定义了需要处理的蛋白质名称列表。

  8. data_dir = Path("/kaggle/input/leash-BELKA"):指定数据存储的目录路径。

  9. model_name = "DeepChem/ChemBERTa-10M-MTR":指定使用的预训练BERT模型的名称。

  10. batch_size = 256:指定训练中使用的批量大小。

  11. trainer_params:定义了训练器的参数,包括最大训练周期数、是否启用进度条、使用的加速器、精度、梯度裁剪值、累积梯度批次数以及使用的设备。

4、准备数据集

df = pl.read_parquet(Path(data_dir, "train.parquet"),columns=["molecule_smiles", "protein_name", "binds"],n_rows=N_ROWS,
)
test_df = pl.read_parquet(Path(data_dir, "test.parquet"),columns=["molecule_smiles"],n_rows=10000 if DEBUG else None,
)
df.head()

这里读取了训练数据和测试数据,并显示了训练数据的前几行。

dfs = []
for i, protein_name in enumerate(PROTEIN_NAMES):sub_df = df[i::3]sub_df = sub_df.rename({"binds": protein_name})if i == 0:dfs.append(sub_df.drop(["id", "protein_name"]))else:dfs.append(sub_df[[protein_name]])
df = pl.concat(dfs, how="horizontal")
df = df.sample(n=N_SAMPLES)
print(df.head())
print(df[PROTEIN_NAMES].sum())
  1. dfs = []:初始化一个空列表,用于存储每个蛋白质的子数据框。

  2. for i, protein_name in enumerate(PROTEIN_NAMES)::使用enumerate函数遍历PROTEIN_NAMES列表中的每个蛋白质名称,同时获取其对应的索引值i和名称protein_nameenumerate函数用于同时遍历一个可迭代对象(如列表、元组)中的元素及其对应的索引。

  3. sub_df = df[i::3]:根据索引i对原始数据框df进行切片操作,每隔3行取出一个子数据框。这样可以将原始数据按照每个蛋白质分成3份,分别处理。

  4. sub_df = sub_df.rename({"binds": protein_name}):将子数据框的列名binds重命名为当前蛋白质的名称,以便后续处理和识别。

  5. if i == 0::如果是第一个蛋白质,则将子数据框中的"id"和"protein_name"列删除,并将处理后的子数据框添加到dfs列表中。

  6. else::如果不是第一个蛋白质,则只保留当前蛋白质的绑定情况数据,并将处理后的子数据框添加到dfs列表中。

  7. df = pl.concat(dfs, how="horizontal"):将所有处理后的子数据框按水平方向拼接成一个新的数据框df

  8. df = df.sample(n=N_SAMPLES):从新的数据框df中随机抽样N_SAMPLES个样本。

  9. print(df.head()):打印新数据框df的前几行。

  10. print(df[PROTEIN_NAMES].sum()):计算新数据框df中每个蛋白质的绑定情况,并打印出来。

def normalize(x):mol = Chem.MolFromSmiles(x)smiles = Chem.MolToSmiles(mol, canonical=True, isomericSmiles=False)return smilesif NORMALIZE:df = df.with_columns(pl.col("molecule_smiles").map_elements(normalize, return_dtype=pl.Utf8))test_df = test_df.with_columns(pl.col("molecule_smiles").map_elements(normalize, return_dtype=pl.Utf8))

这部分代码定义了一个函数normalize(),用于对分子结构的SMILES表示进行规范化。如果NORMALIZE为True,则对训练数据和测试数据中的分子SMILES进行规范化处理。

  1. normalize 函数:这个函数接受一个 SMILES 表示的分子作为输入,并返回规范化后的 SMILES 表示。在这里,它使用了 RDKit 包中的功能。Chem.MolFromSmiles() 将输入的 SMILES 字符串转换为 RDKit 的分子对象,然后 Chem.MolToSmiles() 将这个分子对象转换回 SMILES 字符串,使用了 canonical=True 参数确保生成的 SMILES 是规范化的,isomericSmiles=False 则确保不考虑分子的立体异构体。

  2. if NORMALIZE::这个条件语句检查一个名为 NORMALIZE 的变量是否为真。如果为真,就会对数据进行规范化操作。如果 NORMALIZE 是一个布尔值,这个条件通常会在前面被定义,以确定是否要进行规范化处理。

  3. df = df.with_columns(pl.col("molecule_smiles").map_elements(normalize, return_dtype=pl.Utf8)):这一行代码应该是 Pandas 或类似的数据处理库(比如 Dask 或 Modin)的语法。它将 DataFrame 中的 "molecule_smiles" 列中的每个元素都应用 normalize 函数进行规范化处理,然后将结果保存回原来的列中。这里使用了 map_elements() 函数,它是 Pandas 的 apply() 方法的替代,用于元素级别的操作。

  4. test_df = test_df.with_columns(pl.col("molecule_smiles").map_elements(normalize, return_dtype=pl.Utf8)):同上一行,只是这一行是对另一个 DataFrame test_df 执行同样的操作。

train_idx, val_idx = train_test_split(np.arange(len(df)), test_size=0.2)
train_df, val_df = df[train_idx], df[val_idx]
len(train_df), len(val_df)

这段代码将数据拆分为训练集和验证集,比例为80:20。
 

  1. train_test_split(np.arange(len(df)), test_size=0.2):这行代码使用了 train_test_split 函数来将索引数组 np.arange(len(df)) 分割成训练集和验证集的索引。参数 test_size=0.2 指定了验证集所占的比例,这里是20%。训练集和验证集的索引分别存储在 train_idxval_idx 中。

  2. train_df, val_df = df[train_idx], df[val_idx]:这行代码使用了 Pandas 或类似的库的索引功能,将原始 DataFrame df 中对应索引的行划分给训练集和验证集,分别存储在 train_dfval_df 中。

  3. len(train_df), len(val_df):这一行简单地打印出了训练集和验证集的长度,以确认它们的大小是否符合预期。

5、建立数据集

tokenizer = AutoTokenizer.from_pretrained(model_name)

这行代码根据给定的模型名称加载了相应的tokenizer,用于将文本数据转换成模型输入。

def tokenize(batch, tokenizer):output = tokenizer(batch["molecule_smiles"], truncation=True)return outputclass LMDataset(Dataset):def __init__(self, df, tokenizer, stage="train"):assert stage in ["train", "val", "test"]self.tokenizer = tokenizerself.stage = stagedf = (datasets.Dataset.from_pandas(df.to_pandas()).map(tokenize, batched=True, fn_kwargs={"tokenizer": self.tokenizer}).to_pandas())self.df = pl.from_pandas(df)def __len__(self):return len(self.df)def __getitem__(self, index):data = self._generate_data(index)data["label"] = self._generate_label(index)return data        def _generate_data(self, index):data = {"input_ids": np.array(self.df[index, "input_ids"]),"attention_mask": np.array(self.df[index, "attention_mask"]),}return datadef _generate_label(self, index):if self.stage == "test":return np.array([0, 0, 0])else:return self.df[index, PROTEIN_NAMES].to_numpy()[0]LMDataset(train_df[:100], tokenizer)[0]
  1. tokenize 函数:这是一个辅助函数,接受一个批次的数据和一个分词器(tokenizer),并对批次中的分子 SMILES 进行分词处理。在这里,使用了 Hugging Face Transformers 库提供的 tokenizer 对批次中的分子 SMILES 进行分词,设置了 truncation=True 以确保分词后的序列长度不超过指定的最大长度。

  2. LMDataset 类:这是一个自定义的 PyTorch Dataset 类,用于加载数据集。主要功能包括:

    • __init__ 方法:初始化数据集对象。接受一个 DataFrame df、一个分词器 tokenizer 和一个阶段 stage(默认为 "train")。在这个方法中,将输入的 DataFrame 转换为 PyTorch 的 Dataset 对象,并使用 map 方法对数据进行分词处理,得到包含分词结果的 DataFrame,并将其转换为 Polars 的 DataFrame。
    • __len__ 方法:返回数据集的长度,即数据集中样本的数量。
    • __getitem__ 方法:根据给定的索引 index 返回对应的样本数据和标签。在这里,调用了 _generate_data_generate_label 方法来生成数据和标签。
    • _generate_data 方法:根据给定的索引 index 生成数据。返回一个字典,包含 "input_ids" 和 "attention_mask"。
    • _generate_label 方法:根据给定的索引 index 生成标签。如果阶段为 "test",则返回一个全为 0 的数组;否则,根据索引获取对应的样本的标签值。
  3. LMDataset(train_df[:100], tokenizer)[0]:创建了一个 LMDataset 对象,并取出第一个样本的数据和标签。

class LBDataModule(L.LightningDataModule):def __init__(self, train_df, val_df, test_df, tokenizer):super().__init__()self.train_df = train_dfself.val_df = val_dfself.test_df = test_dfself.tokenizer = tokenizerdef _generate_dataset(self, stage):if stage == "train":df = self.train_dfelif stage == "val":df = self.val_dfelif stage == "test":df = self.test_dfelse:raise NotImplementedErrordataset = LMDataset(df, self.tokenizer, stage=stage)return datasetdef _generate_dataloader(self, stage):dataset = self._generate_dataset(stage)if stage == "train":shuffle=Truedrop_last=Trueelse:shuffle=Falsedrop_last=Falsereturn DataLoader(dataset,batch_size=batch_size,shuffle=shuffle,drop_last=drop_last,pin_memory=True,collate_fn=DataCollatorWithPadding(self.tokenizer),)def train_dataloader(self):return self._generate_dataloader("train")def val_dataloader(self):return self._generate_dataloader("val")def test_dataloader(self):return self._generate_dataloader("test")datamodule = LBDataModule(train_df, val_df, test_df, tokenizer)

  1. __init__ 方法:初始化 DataModule 类,接受训练集、验证集、测试集的 DataFrame 数据以及一个分词器 tokenizer。在这个方法中,将输入的数据和分词器保存到类的属性中。

  2. _generate_dataset 方法:根据给定的阶段("train"、"val" 或 "test"),生成对应阶段的数据集对象。根据阶段选择对应的 DataFrame 数据,然后使用 LMDataset 类创建相应的数据集对象,并传入对应的 DataFrame 和分词器。

  3. _generate_dataloader 方法:根据给定的阶段("train"、"val" 或 "test"),生成对应阶段的数据加载器对象。调用 _generate_dataset 方法生成对应阶段的数据集对象,然后根据阶段设定加载器的参数,如是否打乱数据、是否丢弃最后一个不完整的批次等,最后使用 PyTorch 的 DataLoader 类创建数据加载器对象。

  4. train_dataloaderval_dataloadertest_dataloader 方法:分别返回训练、验证和测试阶段的数据加载器对象,通过调用 _generate_dataloader 方法实现。

  5. datamodule 实例:使用给定的训练集、验证集、测试集和分词器创建了一个 DataModule 对象。

6、建立模型

class LMModel(nn.Module):def __init__(self, model_name):super().__init__()self.config = AutoConfig.from_pretrained(model_name, num_labels=3)self.lm = AutoModel.from_pretrained(model_name, add_pooling_layer=False)self.dropout = nn.Dropout(self.config.hidden_dropout_prob)self.classifier = nn.Linear(self.config.hidden_size, self.config.num_labels)self.loss_fn = nn.BCEWithLogitsLoss(reduction="mean")def forward(self, batch):last_hidden_state = self.lm(batch["input_ids"],attention_mask=batch["attention_mask"],).last_hidden_statelogits = self.classifier(self.dropout(last_hidden_state[:, 0]))return {"logits": logits,}def calculate_loss(self, batch):output = self.forward(batch)loss = self.loss_fn(output["logits"], batch["labels"].float())output["loss"] = lossreturn outputLMModel(model_name)

  1. class LMModel(nn.Module):: 这是定义了一个名为 LMModel 的类,它继承自 nn.Module,表示这个类是一个 PyTorch 模型。

  2. def __init__(self, model_name):: 这是 LMModel 类的初始化函数,接受一个参数 model_name,表示要使用的预训练语言模型的名称。

  3. self.config = AutoConfig.from_pretrained(model_name, num_labels=3): 使用 Hugging Face 的 AutoConfig 类从预训练模型 model_name 中加载配置。num_labels=3 指定了模型的输出类别数量为 3。

  4. self.lm = AutoModel.from_pretrained(model_name, add_pooling_layer=False): 使用 Hugging Face 的 AutoModel 类从预训练模型 model_name 中加载模型,add_pooling_layer=False 表示不添加池化层。

  5. self.dropout = nn.Dropout(self.config.hidden_dropout_prob): 创建了一个 Dropout 层,用于在训练过程中随机将一部分神经元的输出置为零,以防止过拟合。

  6. self.classifier = nn.Linear(self.config.hidden_size, self.config.num_labels): 创建了一个线性层,将语言模型的隐藏状态映射到指定数量的标签上。

  7. self.loss_fn = nn.BCEWithLogitsLoss(reduction="mean"): 创建了一个二元交叉熵损失函数,用于计算模型的损失。这里使用 BCEWithLogitsLoss 是因为多标签分类问题中每个标签都是独立的,所以对每个标签使用二元交叉熵损失。

  8. def forward(self, batch):: 这是模型的前向传播函数,接受一个批次的输入数据 batch,包括输入的标记化的文本和注意力掩码。

  9. last_hidden_state = self.lm(: 使用加载的语言模型处理输入数据,得到最后一层的隐藏状态。

  10. logits = self.classifier(: 将最后一层隐藏状态经过线性层映射到标签空间,得到每个标签的预测概率。

  11. def calculate_loss(self, batch):: 这是计算模型损失的函数,接受一个批次的输入数据 batch

  12. output = self.forward(batch): 调用前向传播函数得到模型的输出结果。

  13. loss = self.loss_fn(output["logits"], batch["labels"].float()): 使用损失函数计算模型的损失,将预测的概率和真实标签进行比较。

  14. output["loss"] = loss: 将计算得到的损失保存在输出字典中。

class LBModelModule(L.LightningModule):def __init__(self, model_name):super().__init__()self.model = LMModel(model_name)self.map = AveragePrecision(task="binary")def forward(self, batch):return self.model(batch)def calculate_loss(self, batch, batch_idx):return self.model.calculate_loss(batch)def training_step(self, batch, batch_idx):ret = self.calculate_loss(batch, batch_idx)self.log("train_loss", ret["loss"], on_step=True, on_epoch=True, prog_bar=True, sync_dist=True)return ret["loss"]def validation_step(self, batch, batch_idx):ret = self.calculate_loss(batch, batch_idx)self.log("val_loss", ret["loss"], on_step=False, on_epoch=True, prog_bar=True, sync_dist=True)self.map.update(F.sigmoid(ret["logits"]), batch["labels"].long())def on_validation_epoch_end(self):val_map = self.map.compute()self.log("val_map", val_map, on_step=False, on_epoch=True, prog_bar=True, sync_dist=True)self.map.reset()def predict_step(self, batch, batch_idx, dataloader_idx=0):logits = self.forward(batch)["logits"]probs = F.sigmoid(logits)return probsdef configure_optimizers(self):optimizer = torch.optim.Adam(self.parameters(), lr=0.0001)return {"optimizer": optimizer,}modelmodule = LBModelModule(model_name)

  1. class LBModelModule(L.LightningModule):: 这是定义了一个名为 LBModelModule 的类,它继承自 PyTorch Lightning 的 LightningModule 类,表示这个类是一个 Lightning 模块。

  2. def __init__(self, model_name):: 这是 LBModelModule 类的初始化函数,接受一个参数 model_name,表示要使用的语言模型的名称。

  3. self.model = LMModel(model_name): 创建了一个 LMModel 类的实例作为模型的成员变量,用于处理输入数据并进行预测。

  4. self.map = AveragePrecision(task="binary"): 创建了一个用于计算平均精度的 AveragePrecision 类的实例。

  5. def forward(self, batch):: 这是模型的前向传播函数,接受一个批次的输入数据 batch,并调用模型的前向传播函数。

  6. def calculate_loss(self, batch, batch_idx):: 这是计算损失的函数,接受一个批次的输入数据 batch 和批次的索引 batch_idx

  7. def training_step(self, batch, batch_idx):: 这是训练步骤函数,在每个训练步骤中计算损失并更新训练日志。

  8. def validation_step(self, batch, batch_idx):: 这是验证步骤函数,在每个验证步骤中计算损失并更新验证日志。

  9. def on_validation_epoch_end(self):: 这是在每个验证轮结束后调用的函数,在这里计算验证集上的平均精度并重置计算器。

  10. def predict_step(self, batch, batch_idx, dataloader_idx=0):: 这是预测步骤函数,用于在每个预测步骤中生成预测概率。

  11. def configure_optimizers(self):: 这是配置优化器的函数,返回一个优化器的配置字典,这里使用 Adam 优化器。

7、训练

checkpoint_callback = ModelCheckpoint(filename=f"model-{{val_map:.4f}}",save_weights_only=True,monitor="val_map",mode="max",dirpath="/kaggle/working",save_top_k=1,verbose=1,
)
early_stop_callback = EarlyStopping(monitor="val_map", mode="max", patience=3)
progress_bar_callback = TQDMProgressBar(refresh_rate=1)
callbacks = [checkpoint_callback,early_stop_callback,progress_bar_callback,
]
  1. ModelCheckpoint: 这个回调函数用于在训练过程中保存模型的检查点,以便在训练结束后选择最佳的模型参数。参数解释如下:

    • filename: 模型文件名的格式,可以使用格式化字符串指定变量,这里使用了验证集的平均精度作为文件名。
    • save_weights_only: 设置为 True 表示只保存模型的权重。
    • monitor: 监控的指标,这里选择了验证集的平均精度。
    • mode: 模型选择的模式,这里选择了最大化验证集的平均精度。
    • dirpath: 模型保存的目录路径。
    • save_top_k: 保存最佳模型的数量,这里设置为 1。
    • verbose: 控制是否在保存模型时输出信息,设置为 1 表示输出信息。
  2. EarlyStopping: 这个回调函数用于在验证集指标停止提升时提前停止训练,以防止过拟合。参数解释如下:

    • monitor: 监控的指标,这里同样选择了验证集的平均精度。
    • mode: 模型选择的模式,这里同样选择了最大化验证集的平均精度。
    • patience: 容忍多少个 epoch 内指标没有提升。
  3. TQDMProgressBar: 这个回调函数用于在训练过程中显示进度条,以便实时监控训练进度。参数 refresh_rate 控制刷新频率,即进度条更新的时间间隔。

trainer = L.Trainer(callbacks=callbacks, **trainer_params)
trainer.fit(modelmodule, datamodule)
  1. trainer = L.Trainer(callbacks=callbacks, **trainer_params): 这行代码创建了一个 Lightning Trainer 对象,并设置了回调函数和训练参数。参数解释如下:

    • callbacks: 指定了训练过程中要使用的回调函数列表,这里使用了之前定义的 callbacks 列表,包括模型检查点、提前停止和进度条回调。
    • **trainer_params: 使用 ** 语法将字典 trainer_params 中的所有键值对作为参数传递给 Trainer 对象,这里包括了一系列训练参数,如最大 epoch 数、设备选择、精度设置等。
  2. trainer.fit(modelmodule, datamodule): 这行代码使用创建的 Trainer 对象开始了模型的训练过程。参数解释如下:

    • modelmodule: 指定了要训练的 Lightning 模型,这里是之前定义的 LBModelModule 对象。
    • datamodule: 指定了训练数据的 datamodule,这里是之前定义的 LBDataModule 对象,其中包含了训练、验证和测试数据集的处理逻辑。

8、推理

test_df = pl.read_parquet(Path(data_dir, "test.parquet"),columns=["molecule_smiles"],n_rows=10000 if DEBUG else None,
)
  • pl.read_parquet: 这是 PyTorch Lightning 库中的一个函数,用于从 Parquet 格式的文件中读取数据。Parquet 是一种列式存储格式,常用于大规模数据存储和处理。
  • Path(data_dir, "test.parquet"): 这是指定要读取的 Parquet 文件的路径。data_dir 是之前定义的数据目录路径,"test.parquet" 是要读取的文件名。
  • columns=["molecule_smiles"]: 这是指定要读取的列名,即从 Parquet 文件中选择的列。在这里,只选择了名为 "molecule_smiles" 的列。
  • n_rows=10000 if DEBUG else None: 这是指定要读取的行数。如果 DEBUG 变量为 True,则只读取文件的前 10000 行;否则,读取整个文件。这是一种常用的技术,用于在开发和调试阶段快速处理较小的数据样本,以加快开发速度。
working_dir = Path("/kaggle/working")
model_paths = working_dir.glob("*.ckpt")
test_dataloader = datamodule.test_dataloader()
for model_path in model_paths:print(model_path)modelmodule = LBModelModule.load_from_checkpoint(checkpoint_path=model_path,model_name=model_name,)predictions = trainer.predict(modelmodule, test_dataloader)predictions = torch.cat(predictions).numpy()pred_dfs = []for i, protein_name in enumerate(PROTEIN_NAMES):pred_dfs.append(test_df.with_columns(pl.lit(protein_name).alias("protein_name"),pl.lit(predictions[:, i]).alias("binds"),))pred_df = pl.concat(pred_dfs)submit_df = (pl.read_parquet(Path(data_dir, "test.parquet"), columns=["id", "molecule_smiles", "protein_name"]).join(pred_df, on=["molecule_smiles", "protein_name"], how="left").select(["id", "binds"]).sort("id"))submit_df.write_csv(Path(working_dir, f"submission_{model_path.stem}.csv"))
  1. 定义了一个工作目录 working_dir,这是保存模型和生成提交文件的目录。
  2. 使用 glob 方法获取工作目录中的所有模型文件的路径,并存储在 model_paths 变量中。
  3. 获取测试数据的数据加载器 test_dataloader
  4. 遍历模型文件路径列表 model_paths
  5. 加载每个模型并进行预测。首先,使用 LBModelModule.load_from_checkpoint 方法加载模型,并传入模型文件路径和模型名称。然后使用 trainer.predict 方法对测试数据进行预测,得到预测结果。
  6. 将预测结果与相应的蛋白质名称关联,并将结果存储在 pred_df 中。
  7. 读取测试数据的 Parquet 文件,并选择需要的列("id"、"molecule_smiles" 和 "protein_name")。
  8. 将预测结果与测试数据合并,并只保留 "id" 和 "binds" 列。
  9. 将合并后的结果按照 "id" 进行排序。
  10. 将生成的提交文件写入 CSV 格式,并根据当前模型文件的名称进行命名,存储在工作目录中。

9、集成

sub_files = list(working_dir.glob("submission_*.csv"))
sub_files

 sub_files 是一个列表,包含工作目录中所有以 "submission_" 开头且以 ".csv" 结尾的文件的路径。这些文件名可能会因为模型路径的不同而有所变化,但它们都是模型预测结果的提交文件。

sub_dfs = []
for sub_file in sub_files:sub_dfs.append(pl.read_csv(sub_file))
submit_df = (pl.concat(sub_dfs).group_by("id").agg(pl.col("binds").mean()).sort("id")
)
  1. 循环遍历 sub_files 中的每个文件路径。
  2. 对于每个文件,使用 pl.read_csv(sub_file) 读取 CSV 文件并将其添加到 sub_dfs 列表中。
  3. 使用 pl.concat(sub_dfs) 将所有 DataFrame 连接成一个大的 DataFrame。
  4. 使用 group_by("id") 将数据按照 "id" 列进行分组。
  5. 使用 .agg(pl.col("binds").mean()) 对每个分组计算 "binds" 列的平均值。
  6. 最后使用 .sort("id") 按照 "id" 列进行排序。
!rm -fr *

 这是一个Unix/Linux命令,用于删除当前目录下的所有文件和文件夹。具体地说:

  • rm 是 remove 的缩写,用于删除文件或目录。
  • -fr 是两个选项的结合:
    • -f 表示强制删除,即不会提示确认。
    • -r 表示递归删除,即删除目录及其下所有文件和子目录。
  • * 是通配符,代表当前目录下的所有文件和文件夹。

因此,这个命令的意思是:删除当前目录下的所有文件和文件夹,且不会提示确认。

submit_df.write_csv(Path(working_dir, "submission.csv"))
  • submit_df 是一个 DataFrame,其中包含了提交的数据。
  • write_csv 是一个方法,用于将 DataFrame 写入到 CSV 格式的文件中。
  • Path(working_dir, "submission.csv") 创建了一个路径对象,指定了要写入的文件路径,这个路径对象表示当前工作目录下的 "submission.csv" 文件。

 10、改进方向

  • 寻找最佳的交叉验证策略
  • 增加数据
  • 使用更多的特征
  • 更大的模型
  • 调整超参数
  • 集成模型

源代码:Leash Bio: ChemBERTa with all data (kaggle.com)

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Blackwell未来发展之路究竟如何?

英伟达Blackwell如何重塑AI计算的未来? 前言 台湾大学演讲 就在6月2日,英伟达CEO黄仁勋在中国台湾大学综合体育馆发表了最新的演讲。这次黄仁勋的演讲依旧重磅,更值得注意的是这次演讲中还透露了Blackwell今后的发展之路。 介绍Blackwell 介绍…

MongoDB CRUD操作:地理位置查询

MongoDB CRUD操作:地理位置查询 文章目录 MongoDB CRUD操作:地理位置查询地理空间数据GeoJSON对象传统坐标对通过数组指定(首选)通过嵌入文档指定 地理空间索引2dsphere2d 地理空间查询地理空间查询运算符地理空间聚合阶段 地理空…

拿笔记下来!产品采购制造类合同怎样写比较稳妥?

拿笔记下来!产品采购制造类合同怎样写比较稳妥? 近日,几经波折,泰中两国终于完成了潜艇采购谈判!你知道吗?产品制造类合同或协议在起草前如果没有充分考虑各种因素,可能会导致一系列问题和不利…

C语言学习:数据类型

一、 为什么要引入数据类型 • 计算机中每个字节都有一个地址(类似门牌号) • CPU通过 地址 来访问这个字节的空间 0x20001103 1 0 0 1 0 0 1 1 0x20001102 1 1 1 0 1 1 1 0 0x20001101 1 1 1 1 0 1 0 1 0x20001100 0 …

无人监控视频输出卡顿状态

设计思路,如下: 1.通过采集卡将视频信号输出到个人PC中 2.PC按设置好的时间,视频属性分片保存 3.将步骤2中的视频,按预处理要求,得到待计算的视频片段 4.使用SSIM算法计算预处理后的视频,将计算得到的数据存…

聊天机器人的实践过程

一、语聊机器人 OpenAI 的爆火,到如今也才一年多的时间,然而在过去的一年中,生成式AI的落地场景几乎 80%都是 ChatBot 的形式,那么今天这篇文章我们就来聊一下,生成式AI和IM能擦出怎么样的火花?以及各种场…

p13idea的其他操作

1 导入模块 错误示范: 正确示范: 2 删除模块 必须用delete才能删除干净,用remove删了之后还要回到文件里面把它删除掉

有钱还系统源码 人人还众筹还钱模式还贷系统源码

盈利模式: 1.系统里直推400 2.间推得200 3.升级是隔代匹配200 4.漏单直接设置归系统 5.九级匹配不到直接归平台 有钱还平台新注册会员,即新入的负债者要分9次分别资助先来的11名负债者每人200元,这笔资助不是一次性给到对方&#xff0c…

Mybatis的一级缓存

缓存 MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。MyBatis 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。 Mybatis和Hibernate一样,也有一级和二级缓存,同样默认开启的只有一级缓存,二级缓…

脑部磁共振成像肿瘤分割方法(MATLAB 2018)

近年脑肿瘤发病率呈上升趋势,约占全身肿瘤的5%,占儿童肿瘤的70%。CT、MRI等多种影像检查方法可用于检测脑肿瘤,其中MRI应用于脑肿瘤成像效果最佳。精准的脑肿瘤分割是病情诊断、手术规划及后期治疗的必备条件,既往研究者对脑部肿瘤…

Python知识点12---Python的I/O操作

提前说一点:如果你是专注于Python开发,那么本系列知识点只是带你入个门再详细的开发点就要去看其他资料了,而如果你和作者一样只是操作其他技术的Python API那就足够了。 Python的流(I/O)操作,最简单的其实就是输入和输出&#x…

工厂的精益生产如此重要

什么是工厂的精益生产 精益生产(Lean Manufacturing)是一种起源于20世纪50年代日本丰田汽车公司的生产管理哲学。它的核心理念是通过消除生产过程中的浪费,优化流程,提高效率,从而实现成本降低和质量提升。精益生产不仅…

VRTK4.0学习——(二)

手柄绑定以及显示 1.导入CameraRigs.UnityXRPluginFramework 和 CameraRigs.TrackedAlias 预设,将CameraRigs.UnityXRPluginFramework拖入CameraRigs.TrackedAlias的Elements中即可,运行软件后即可看到手柄了 注:如果无法看到手柄&#xff…

MySQL:MySQL执行一条SQL查询语句的执行过程

当多个客户端同时连接到MySQL,用SQL语句去增删改查数据,针对查询场景,MySQL要保证尽可能快地返回客户端结果。 了解了这些需求场景,我们可能会对MySQL进行如下设计: 其中,连接器管理客户端的连接,负责管理连接、认证鉴权等;查询缓存则是为了加速查询,命中则直接返回结…

系统介绍在线直线度测量仪的测量原理

测头的测量原理 蓝鹏光电测头采用的是CCD成像法测量,CCD成像法是指将被测物放置在物方远心光路系统中进行成像,并利用成像位置的CCD芯片接收成像信息进行尺寸测量的方法。该测量方法的优点主要有两个:一是成像边界清晰,光电信号可…

从墙的功能出发 -分析欧特克Revit和广联达数维的差别

欧特克(Autodesk)在三维建模软件领域的影响力是有目共睹的,它是行业的头部产商,拥有众多的高质量的三维设计软件,涵盖了建筑设计、机械设计与制造和电影文娱行业。Revit是其发布的建筑三维建模软件,也是BIM…

如何用个人电脑搭建一台本地服务器,并部署项目到服务器详细教程(Ubuntu镜像)

前言 VirtualBox虚拟机软件是一款强大、免费且开源的虚拟化工具,它允许用户在单一物理机器上同时运行多个操作系统。他对比VMware就是更轻量级的虚拟机软件,而且操作更简单。 下载地址:Download_Old_Builds_7_0 – Oracle VM VirtualBox …

SpringMVC日期格式处理 分页条件查询

实现日期格式处理 实现分页条件查询: 分页条件查询 和 查询所有 是两个不同的方法,使用同一个mapper的查询功能,但是两个不同的业务方法 ​​​​​​​

24年西藏事业单位报名详细流程

✨各位姐妹们注意啦!24西藏事业单位公告已出,本次计划公开招聘8⃣9⃣9⃣人即日起开始报名,想要上岸的姐妹们要抓紧了哦✊趁着还有时间赶紧开卷!!! 🌈24西藏事业单位招聘考试: &…

k8s练习--StorageClass详细解释与应用

文章目录 前言StorageClass是什么 一、实验目的配置过程 二、实验环境实验步骤一、配置网络存储NFS:1.主机基础配置2.配置 NFS: 二、开启rbac权限:三、创建nfs-deployment.yaml四、创建storageclass资源五、验证:1.创建PVC验证2.创建一个pod验…