特征工程技巧—Bert

news2024/11/26 17:23:54

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

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

  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_name。enumerate函数用于同时遍历一个可迭代对象（如列表、元组）中的元素及其对应的索引。

  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 smiles


if 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_idx 和 val_idx 中。

  2. train_df, val_df = df[train_idx], df[val_idx]：这行代码使用了 Pandas 或类似的库的索引功能，将原始 DataFrame df 中对应索引的行划分给训练集和验证集，分别存储在 train_df 和 val_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 output


class LMDataset(Dataset):
    def __init__(self, df, tokenizer, stage="train"):
        assert stage in ["train", "val", "test"]
        self.tokenizer = tokenizer
        self.stage = stage
        df = (
            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 data
    
    def _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_df
        self.val_df = val_df
        self.test_df = test_df
        self.tokenizer = tokenizer

    def _generate_dataset(self, stage):
        if stage == "train":
            df = self.train_df
        elif stage == "val":
            df = self.val_df
        elif stage == "test":
            df = self.test_df
        else:
            raise NotImplementedError
        dataset = LMDataset(df, self.tokenizer, stage=stage)
        return dataset

    def _generate_dataloader(self, stage):
        dataset = self._generate_dataset(stage)
        if stage == "train":
            shuffle=True
            drop_last=True
        else:
            shuffle=False
            drop_last=False
        return 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_dataloader、val_dataloader 和 test_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_state
        logits = 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"] = loss
        return output

    
LMModel(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 probs

    def 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.coloradmin.cn/o/1795370.html

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

相关文章

制造执行MES系统在光伏行业的应用

制造执行MES系统在光伏行业的应用

全球对可再生能源的需求不断增长，光伏能源作为一种清洁、可持续的能源形式，已经在广泛应用中受到了广泛关注。为满足工业领域的光伏能源需求，光伏制造执行系统(MES)作为一种集成化的技术解决方案，提供了更高效、更可靠的解决方案。…
阅读更多...
海外仓系统推荐：中小型海外仓和家庭海外仓如何低投入高营收

海外仓系统推荐：中小型海外仓和家庭海外仓如何低投入高营收

随着海外仓行业整体竞争的加剧，海外仓的管理和经营成本可以说也是水涨船高。这对一些集团性质的大型海外仓影响不大，因为他们可以通过规模效应来摊薄成本。 但是对中小型海外仓和一些家庭海外仓来说，影响将是巨大的。一方面，海外…
阅读更多...
GLM-4开源版本终于发布！！性能超越Llama3，多模态媲美GPT-4V，MaaS平台全面升级

GLM-4开源版本终于发布！！性能超越Llama3，多模态媲美GPT-4V，MaaS平台全面升级

今天上午，在 AI 开放日上，备受关注的大模型公司智谱 AI 公布了一系列行业落地数据： 根据最新统计，智谱 AI 大模型开放平台目前已拥有 30 万注册用户，日均调用量达到 4000 亿 Tokens。GPT-4o深夜发布！Plus免…
阅读更多...
【重学C语言】十八、SDL2 图形编程介绍和环境配置

【重学C语言】十八、SDL2 图形编程介绍和环境配置

【重学C语言】十八、SDL2 图形编程介绍和环境配置 **SDL2介绍**SDL 2用途SDL 在哪些平台上运行？下载和安装 SDL2安装 SDL2 clion 配置 SDL2 SDL2介绍 SDL2（Simple DirectMedia Layer 2）是一个开源的跨平台多媒体开发库，主要用于游…
阅读更多...
Cortex系列详解

Cortex系列详解

Cortex系列属于ARMv7架构（ARM公司在经典处理器ARM11以后的产品改用Cortex命名） 一、Cortex-A系列 “A”系列面向尖端的基于虚拟内存的操作系统和用户应用。 A 系列处理器适用于具有高计算要求、运行丰富操作系统以及提供交互媒体和图形体验的应用领域。 具体案例如：智能手…
阅读更多...
2024百度之星 跑步

2024百度之星 跑步

原题链接：码题集OJ-跑步 题目大意：一个n个人在绕圈跑，第i个人跑一圈的时间是i分钟，每二个人位置相同就会打一次招呼，如果同时来到终点，他们就会停下来，请问会打多少次招呼？ 思路&a…
阅读更多...
文件加密软件排行榜前五名｜好用的五款文件加密软件分享

文件加密软件排行榜前五名｜好用的五款文件加密软件分享

你的公司是否存在这些问题： 数据泄露事件常有发生，数据安全的重要性日益凸显，而文件加密软件则是保护数据安全的重要工具。 市场上存在众多文件加密软件，每款都有其独特的特点和优势。 本文将为您分享五款好用的文件加密软件&…
阅读更多...
java通过ftp上传文件到服务器

java通过ftp上传文件到服务器

依赖 <!-- https://mvnrepository.com/artifact/com.jcraft/jsch --><dependency><groupId>com.jcraft</groupId><artifactId>jsch</artifactId><version>0.1.55</version></dependency> 代码 package com.cyz; impor…
阅读更多...
Docker高级篇之Dockerfile解析

Docker高级篇之Dockerfile解析

文章目录 1. DockerFile简介2. DockerFile的构建过程3. DockerFile的常用保留字4. 使用案例5. 虚悬镜像 1. DockerFile简介 DockerFile是用来构建Docker镜像的文本文件&#xff0c;是由一条条构建镜像的指令和参数构成的脚本。 2. DockerFile的构建过程 DockerFile内容的基…
阅读更多...
2.3 OpenCV随手简记（四）

2.3 OpenCV随手简记（四）

阈值处理是很多高级算法底层处理的预方法之一。 自己求图像平均阈值&#xff1a; # -*- codingGBK -*- import cv2 as cv import numpy as np #求出图像均值作为阈值来二值化 def custom_image(image): gray cv.cvtColor(image, cv.COLOR_BGR2GRAY) cv.imshow("原来&qu…
阅读更多...
精选网络安全书单：打造数字世界的钢铁长城！

精选网络安全书单：打造数字世界的钢铁长城！

目录 1.前言 2.书单推荐 2.1. 《内网渗透实战攻略》 2.2. 《Kali Linux高级渗透测试&#xff08;原书第4版&#xff09;》 2.3. 《CTF那些事儿》 2.4. 《权限提升技术&#xff1a;攻防实战与技巧》 2.5. 《数字政府网络安全合规性建设指南&#xff1a;密码应用与数据安全…
阅读更多...
CentOS6系统因目录有隐含i权限属性致下属文件无法删除的故障一例

CentOS6系统因目录有隐含i权限属性致下属文件无法删除的故障一例

CentOS6服务器在升级openssh时因系统目录权限异常&#xff08;有隐含i权限属性&#xff09;&#xff0c;下属文件无法删除&#xff0c;导致系统问题的故障一例。 一、问题现象 CentOS6在升级openssh时&#xff0c;提示如下问题&#xff1a; warning: /etc/ssh/sshd_config c…
阅读更多...
五个超实用的 ChatGPT-4o 提示词

五个超实用的 ChatGPT-4o 提示词

GPT-4o 是 OpenAI 最近推出的最新人工智能模型&#xff0c;不仅具备大语言模型的能力&#xff0c;而且拥有多模态模型的看、读、说等能力&#xff0c;而且速度比 GPT-4 更快。下面我们就来介绍几个超实用的 GPT-4o 提示词&#xff0c;帮助大家更好地了解 GPT-4o 的功能和应用场…
阅读更多...
Vuforia AR篇（五）— 地平面检测

Vuforia AR篇（五）— 地平面检测

目录 前言一、什么是地平面识别&#xff1f;二、使用步骤三、示例代码四、效果五、总结 前言 在增强现实&#xff08;AR&#xff09;应用程序的开发中&#xff0c;地平面识别是一项关键技术&#xff0c;它允许虚拟对象与现实世界的地面进行互动。Vuforia 是一个功能强大的 AR …
阅读更多...
SpringBoot引入WebSocket依赖报ServerContainer no avaliable

SpringBoot引入WebSocket依赖报ServerContainer no avaliable

1、WebSocketConfig 文件报错 Configuration EnableWebSocket public class WebSocketConfig {Beanpublic ServerEndpointExporter serverEndpointExporter() {return new ServerEndpointExporter();}2、报错内容 Exception encountered during context initialization - canc…
阅读更多...
UFS协议—新手快速入门（二）【5-6】

UFS协议—新手快速入门（二）【5-6】

目录 五、UFS协议栈 六、UFS技术演进与详解 1、UFS应用层 设备管理器 任务管理器 2、UFS传输层 3、UFS互联层 UFS协议—新手快速入门&#xff08;一&#xff09;【1-4】 五、UFS协议栈 UFS&#xff08;Universal Flash Storage&#xff09;协议是针对固态存储设备&…
阅读更多...
德国西门子论未来质量管理 - 如何与明天相遇？

德国西门子论未来质量管理 - 如何与明天相遇？

未来制造业的质量 -- 如何用软件方案满足质量要求 作者&#xff1a;Bill Butcher 翻译&编辑&#xff1a;数字化营销工兵 【前言】在Frost&Sullivan最近发表的一份白皮书中&#xff0c;他们讨论了制造业的质量投资。质量是制造过程的关键要素&#xff0c;但似乎比其他…
阅读更多...
Ubuntu部署开源网关Apache APISIX

Ubuntu部署开源网关Apache APISIX

说明 系统&#xff1a;Ubuntu 24.04 LTSDocker版本&#xff1a;v26.1.3Docker Compose版本&#xff1a;v2.26.1 下载和配置 Ubuntu需要安装Docker和Docker Compose 下载apisix-docker仓库 git clone https://github.com/apache/apisix-docker.git修改docker-compose 配置e…
阅读更多...
嵌入式学习记录6.6（拷贝构造/友元函数/常成员函数）

嵌入式学习记录6.6（拷贝构造/友元函数/常成员函数）

一.拷贝构造函数和拷贝赋值函数 1.1拷贝构造函数功能,格式 拷贝构造函数是一种特殊的构造函数&#xff0c;用来将一个类对象给另一个类对象初始化使用的。 1> 用一个类对象给另一个类对象初始化时&#xff0c;会自动调用拷贝构造函数。 2> 当一个类对作为函数的实参&…
阅读更多...
【Linux】Linux环境基础开发工具_5

【Linux】Linux环境基础开发工具_5

文章目录 四、Linux环境基础开发工具Linux小程序---进度条git 未完待续 四、Linux环境基础开发工具 Linux小程序—进度条 上篇我们实现了一个简易的进度条&#xff0c;不过那仅仅是测试&#xff0c;接下来我们真正的正式实现一个进度条。 接着编写 processbar.c 文件 然…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023