补充：RNN详解(Recurrent Neural Network)-CSDN博客

循环神经网络 （Recurrent Neural Network, RNN）是一类具有内部环状连接的人工神经网络，用于处理序列数据。其最大特点是网络中存在着环，使得信息能在网络中进行循环，实现对序列信息的存储和处理。

RNN的基本结构：

<code># 一个简单的RNN结构示例

class SimpleRNN(nn.Module):

def __init__(self, input_size, hidden_size):

super(SimpleRNN, self).__init__()

self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)

def forward(self, x):

out, _ = self.rnn(x)

return out

类定义:

class SimpleRNN(nn.Module):

这里定义了一个名为 SimpleRNN 的类，它继承自 nn.Module。nn.Module 是PyTorch中所有神经网络模块的基类，提供了一些基础功能。

构造函数:

def __init__(self, input_size, hidden_size): super(SimpleRNN, self).__init__() self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)

input_size: 输入特征的维度。hidden_size: RNN隐藏层的维度。super(SimpleRNN, self).__init__(): 调用基类的构造函数，这是Python中继承机制的一部分。self.rnn: 创建一个 nn.RNN 实例。nn.RNN 是PyTorch中实现基本RNN的类。

第一个参数 input_size 指定了输入特征的维度。第二个参数 hidden_size 指定了隐藏层的维度。batch_first=True 指示输入和输出张量的第一个维度是批次大小（batch size），这使得模型的输入输出格式更加灵活。

前向传播函数:

def forward(self, x): out, _ = self.rnn(x) return out

x: 输入数据，通常是一个三维张量，其形状为 (batch_size, seq_length, input_size)，其中：

batch_size 是批次中的样本数。seq_length 是序列的长度。input_size 是每个时间步的输入特征数。self.rnn(x): 调用RNN层进行前向传播。RNN层的输出是一个元组，包含：

out: RNN的输出，形状为 (batch_size, seq_length, hidden_size)。_: 这里使用下划线（_）来忽略梯度，因为通常我们只关心输出而不关心隐藏状态的梯度。return out: 返回RNN的输出。

工作原理

输入层：RNN能够接受一个输入序列（例如文字、股票价格、语音信号等）并将其传递到隐藏层。隐藏层：隐藏层之间存在循环连接，使得网络能够维护一个“记忆”状态，这一状态包含了过去的信息。这使得RNN能够理解序列中的上下文信息。输出层：RNN可以有一个或多个输出，例如在序列生成任务中，每个时间步都会有一个输出。

RNN的优缺点

优点：

能够处理不同长度的序列数据。能够捕捉序列中的时间依赖关系。

缺点：

对长序列的记忆能力较弱，可能出现梯度消失或梯度爆炸问题。训练可能相对复杂和时间消耗大。

RNN的应用场景

循环神经网络（RNN）因其在捕获序列数据中的时序依赖性方面的优势，在许多应用场景中都得到了广泛的使用。以下是一些主要应用领域的概述：

词汇表与序列编码

在处理基因序列数据时，通常需要将核酸序列转换为数值表示形式，以便输入到深度学习模型中。词汇表（vocab）是一种将序列中的每个元素（如核苷酸或核苷酸组合）映射到一个唯一的数值索引的结构。在本文中，使用了一个基于3-gram的词汇表，这意味着每三个连续的核苷酸组合成一个“单词”。这种方法能够捕捉序列中的局部模式，并提高模型的预测能力。

数据处理与特征选择

数据处理是机器学习中的关键步骤，包含数据清洗、预处理和特征选择。在本次比赛中，需要对原始数据进行清洗，去除缺失值和异常值。特征选择则是选择最能代表数据特征的字段，以提高模型的性能和训练效率。这里的特征包括siRNA序列、修饰后的siRNA序列、靶mRNA序列以及实验条件（如药物浓度、细胞系、转染方式等）。

模型训练与评估

模型训练是指通过优化算法（如Adam优化器）调整模型参数，使其在训练数据上表现良好。评估模型性能时，常用的指标包括均方误差（MSE）、平均绝对误差（MAE）、精确率（Precision）和召回率（Recall）。在本次比赛中，模型的最终得分由MAE和预测值在一定范围内的F1指标（F1）综合计算而得。训练过程中需要监控验证集上的模型表现，以防止过拟合（在训练过程中，使用交叉验证方法评估模型的泛化能力。通过早停法（Early Stopping）防止过拟合）。

PyTorch框架

PyTorch是一个开源的深度学习框架，广泛用于研究和生产环境中。它提供了灵活的动态计算图，使得模型的定义和训练更加直观和便捷。在本次比赛的baseline代码中，使用了PyTorch构建和训练RNN模型，包括数据加载、序列编码、模型定义、训练循环和评估等步骤。PyTorch的优势在于其简洁的API和强大的功能，能够快速实现复杂的深度学习模型。

Baseline 分块代码如下：

1. 依赖库的导入 

<code>ef forward(self, x):

# 将输入序列传入嵌入层

embedded = [self.embedding(seq) for seq in x]

outputs = []

# 对每个嵌入的序列进行处理

for embed in embedded:

x, _ = self.gru(embed) # 传入GRU层

x = self.dropout(x[:, -1, :]) # 取最后一个隐藏状态，并进行dropout处理

outputs.append(x)

# 将所有序列的输出拼接起来

x = torch.cat(outputs, dim=1)

# 传入全连接层

x = self.fc(x)

# 返回结果

return x.squeeze()

那么这里的输入x是什么呢？我们可以通过train_loader来查看一个batch内的输入情况，这里的inputs和上面的x是一个东西。我们首先发现inputs包含两个元素，它们分别对应的是前面提到的两个使用的特征，每个元素的尺寸都是64*25，64代表batch的大小，25代表序列的长度。这里我们可以从inputs[0][0]看到每一行数据的siRNA_antisense_seq被向量化后的情况，这个例子中我们发现前面的7位是非零数，表示其序列编码后每一位的唯一标识；而后面都是0，这是因为RNN模型的输入需要每个样本的长度一致，因此我们需要事先算出一个所有序列编码后的最大长度，然后补0。

那么我们怎么能得到这个唯一标识呢？我们首先需要把序列给进行分词，siRNA_antisense_seq的分词策略是3个一组（GenomicTokenizer的ngram和stride都取3）进行token拆分，比如AGCCGAGAU会被分为[AGC, CGA, GAU]，而modified_siRNA_antisense_seq_list会进行按照空格分词（因为它本身已经根据空格分好了）。由此我们可以从整个数据集构建出一个词汇表，他负责token到唯一标识（索引）的映射：

有了这个词汇表，我们就可以

来获得序列的最大长度

在loader获取样本的时候把token转为索引

此时，对于某一行数据，其两个特征分别为AGCCUUAGCACA和u u g g u u Cf c，假设整个数据集对应token编码后序列的最大长度为10，那么得到的特征就可能是

[25, 38, 25, 24, 0, 0, 0, 0, 0, 0][65, 65, 63, 63, 65, 65, 74, 50, 0, 0]

那么假设batch的大小为16，此时forword函数的x就会是两个列表，每个列表的tensor尺寸为16 * 10

RNN模型分析 

<code>class SiRNAModel(nn.Module):

def __init__(self, vocab_size, embed_dim=200, hidden_dim=256, n_layers=3, dropout=0.5):

super(SiRNAModel, self).__init__()

# 初始化嵌入层

self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)

# 初始化GRU层

self.gru = nn.GRU(embed_dim, hidden_dim, n_layers, bidirectional=True, batch_first=True, dropout=dropout)

# 初始化全连接层

self.fc = nn.Linear(hidden_dim * 4, 1) # hidden_dim * 4 因为GRU是双向的，有n_layers层

# 初始化Dropout层

self.dropout = nn.Dropout(dropout)

def forward(self, x):

# 将输入序列传入嵌入层

embedded = [self.embedding(seq) for seq in x]

outputs = []

# 对每个嵌入的序列进行处理

for embed in embedded:

x, _ = self.gru(embed) # 传入GRU层

x = self.dropout(x[:, -1, :]) # 取最后一个隐藏状态，并进行dropout处理

outputs.append(x)

# 将所有序列的输出拼接起来

x = torch.cat(outputs, dim=1)

# 传入全连接层

x = self.fc(x)

# 返回结果

return x.squeeze()

我们首先第一步将得到的索引进行了embedding，token的embedding是将离散的符号（如单词、字符、或基因序列片段）映射到连续的向量空间的过程。这个过程通过将高维的稀疏表示（如独热编码）转换为低维的密集向量表示，使得相似的符号在向量空间中距离更近。此时，embed的尺寸会从BatchSize * Length成为BatchSize * Length * EmbeddingSize，此处EmbeddingSize即embed_dim=200。

token：模型输入基本单元。比如中文BERT中，token可以是一个字，也可以是等标识符。embedding：一个用来表示token的稠密的向量。token本身不可计算，需要将其映射到一个  连续向量空间，才可以进行后续运算，这个映射的结果就是该token对应的embedding。

Token Embeddings 是一种将文本中的词语转化为向量表示的方法。在自然语言处理中，我们通常将文本表示为一个向量矩阵，其中每个词语对应一个向量。这些向量被称为词向量或者词嵌入。Token Embeddings 是一种词向量的扩展，它可以将不同类型的词语（如单词、字符、子词）都转化为向量表示。

一起学习大模型 - 从底层了解Token Embeddings的原理（1）-CSDN博客

RNN，全称为递归神经网络（Recurrent Neural Network），是一种人工智能模型，特别擅长处理序列数据。它和普通的神经网络不同，因为它能够记住以前的数据，并利用这些记忆来处理当前的数据。想象你在读一本书。你在阅读每一页时，不仅仅是单独理解这一页的内容，还会记住前面的情节和信息。这些记忆帮助你理解当前的情节并预测接下来的发展。这就是 RNN 的工作方式。假设你要预测一个句子中下一个单词是什么。例如，句子是：“我今天早上吃了一个”。RNN 会根据之前看到的单词（“我今天早上吃了一个”），预测下一个可能是“苹果”或“香蕉”等。它记住了之前的单词，并利用这些信息来做出预测。

RNN 在处理序列数据时具有一定的局限性：

长期依赖问题：RNN 难以记住和利用很久以前的信息。这是因为在长序列中，随着时间步的增加，早期的信息会逐渐被后来的信息覆盖或淡化。

梯度消失和爆炸问题：在反向传播过程中，RNN 的梯度可能会变得非常小（梯度消失）或非常大（梯度爆炸），这会导致训练过程变得困难。

LSTM 的改进

LSTM 通过引入一个复杂的单元结构来解决 RNN 的局限性。LSTM 单元包含三个门（输入门、遗忘门和输出门）和一个记忆单元（细胞状态），这些门和状态共同作用，使 LSTM 能够更好地捕捉长期依赖关系。

输入门：决定当前输入的信息有多少会被写入记忆单元。

遗忘门：决定记忆单元中有多少信息会被遗忘。

输出门：决定记忆单元的哪些部分会作为输出。

通过这些门的控制，LSTM 可以选择性地保留或遗忘信息，从而有效地解决长期依赖和梯度消失的问题。

GRU 的改进

GRU 是 LSTM 的一种简化版本，它通过合并一些门来简化结构，同时仍然保留了解决 RNN 局限性的能力。GRU 仅有两个门：更新门和重置门。

更新门：决定前一个时刻的状态和当前输入信息的结合程度。

重置门：决定忘记多少之前的信息。

GRU 的结构更简单，计算效率更高，同时在许多应用中表现出与 LSTM 类似的性能。

我们在pytorch的GRU文档中可以找到对应可选的参数信息，我们需要特别关注的参数如下，它们决定了模型的输入输出的张量维度

input_size（200）

hidden_size（256）

bidirectional（True）

假设输入的BatchSize为16，序列最大长度为10，即x尺寸为16 * 10 * 200，那么其输出的张量尺寸为 16 * 10 * (256 * 2)。

在从GRU模型输出后，x = self.dropout(x[:, -1, :])使得输出变为了BatchSize * (hidden_dim * 2)，此处取了序列最后一个位置的输出数据（注意RNN网络的记忆性），这里的2是因为bidirectional参数为True，随后x = torch.cat(outputs, dim=1)指定在第二个维度拼接后，通过全连接层再映射为标量，因此最后经过squeeze（去除维数为1的维度）后得到的张量尺寸为批大小，从而可以后续和target值进行loss计算，迭代模型。

进阶

数据的特征工程

在提交官方baseline后，我们会发现得分并不好，这一方面原因可能在于数据用的特征还较为简单，序列特征的构造较为粗糙，再加上对于深度学习的RNN模型而言数据量可能还不太充足的因素，这是可以预见的output。下面我们介绍一种把序列特征的问题转化为表格问题的方法，并介绍在表格数据上如何做特征工程。

处理类别型变量

如何知道一个变量是类别型的呢，只需看下其值的分布，或者唯一值的个数

df.gene_target_symbol_name.nunique()

df.gene_target_symbol_name.value_counts()

<code>.nunique() 是Pandas库中DataFrame对象的一个方法，主要用于计数非空唯一值。当你在一个Series或DataFrame的列上调用这个函数时，它会返回该列中不同元素（即去除了NaN或缺失值）的个数。例如，在基因表达数据框（DataFrame）中，如果你有一个名为“target_gene_symbols”的列，.nunique() 可以告诉你有多少种不同的基因靶点符号。

这个函数常用于数据清洗、预处理和基本的数据探索阶段，因为它可以帮助我们快速了解某个特征的多样性和重复度。如果结果很大，可能意味着数据分布广泛；如果结果很小，那可能意味着存在大量的重复项。

.value_counts() 是Pandas DataFrame或Series对象上的一个统计函数，用于计算每个元素（在这个上下文中通常是观测值或类别）出现的次数。当应用于df.gene_target_symbol_name这样的列时，它会对列中的不同基因目标符号名称进行计数，并返回一个新的Series，其中索引是独特的基因符号名，值则是对应的频率（出现次数）。

 

如果相较于数据的总行数很少，那么其很可能就是类别变量了，比

如 gene_target_symbol_name。此时，我们可以使用get_dummie函数来实现one-hot特征的构造

<code># 如果有40个类别，那么会产生40列，如果第i行属于第j个类别，那么第j列第i行就是1，否则为0

df_gene_target_symbol_name = pd.get_dummies(df.gene_target_symbol_name)

df_gene_target_symbol_name.columns = [

f"feat_gene_target_symbol_name_{c}" for c in df_gene_target_symbol_name.columns

]

get_dummie：pandas.get_dummies （独热编码）详解_pandas独热编码-CSDN博客

one-hot：机器学习：数据预处理之独热编码（One-Hot）详解-CSDN博客

可能的时间特征构造

在数据观察的时候发现，siRNA_duplex_id的编码方式很有意思，其格式为AD-1810676.1，我们猜测AD是某个类别，后面的.1是版本，当中的可能是按照一定顺序的序列号，因此可以构造如下特征：

siRNA_duplex_id_values = df.siRNA_duplex_id.str[3:-2].str.strip(".").astype("int")

包含某些单词

df_cell_line_donor = pd.get_dummies(df.cell_line_donor)

df_cell_line_donor.columns = [

f"feat_cell_line_donor_{c}" for c in df_cell_line_donor.columns

]

# 包含Hepatocytes

df_cell_line_donor["feat_cell_line_donor_hepatocytes"] = (

(df.cell_line_donor.str.contains("Hepatocytes")).fillna(False).astype("int")

)

# 包含Cells

df_cell_line_donor["feat_cell_line_donor_cells"] = (

df.cell_line_donor.str.contains("Cells").fillna(False).astype("int")

)

根据序列模式提取特征

假设siRNA的序列为ACGCA...，此时我们可以根据上一个task中提到的rna背景知识，对碱基的模式进行特征构造：

def siRNA_feat_builder(s: pd.Series, anti: bool = False):

name = "anti" if anti else "sense"

df = s.to_frame()

# 序列长度

df[f"feat_siRNA_{name}_seq_len"] = s.str.len()

for pos in [0, -1]:

for c in list("AUGC"):

# 第一个和最后一个是否是A/U/G/C

df[f"feat_siRNA_{name}_seq_{c}_{'front' if pos == 0 else 'back'}"] = (

s.str[pos] == c

)

# 是否已某一对碱基开头和某一对碱基结尾

df[f"feat_siRNA_{name}_seq_pattern_1"] = s.str.startswith("AA") & s.str.endswith(

"UU"

)

df[f"feat_siRNA_{name}_seq_pattern_2"] = s.str.startswith("GA") & s.str.endswith(

"UU"

)

df[f"feat_siRNA_{name}_seq_pattern_3"] = s.str.startswith("CA") & s.str.endswith(

"UU"

)

df[f"feat_siRNA_{name}_seq_pattern_4"] = s.str.startswith("UA") & s.str.endswith(

"UU"

)

df[f"feat_siRNA_{name}_seq_pattern_5"] = s.str.startswith("UU") & s.str.endswith(

"AA"

)

df[f"feat_siRNA_{name}_seq_pattern_6"] = s.str.startswith("UU") & s.str.endswith(

"GA"

)

df[f"feat_siRNA_{name}_seq_pattern_7"] = s.str.startswith("UU") & s.str.endswith(

"CA"

)

df[f"feat_siRNA_{name}_seq_pattern_8"] = s.str.startswith("UU") & s.str.endswith(

"UA"

)

# 第二位和倒数第二位是否为A

df[f"feat_siRNA_{name}_seq_pattern_9"] = s.str[1] == "A"

df[f"feat_siRNA_{name}_seq_pattern_10"] = s.str[-2] == "A"

# GC占整体长度的比例

df[f"feat_siRNA_{name}_seq_pattern_GC_frac"] = (

s.str.contains("G") + s.str.contains("C")

) / s.str.len()

return df.iloc[:, 1:]

 基于lightgbm的baseline

在得到了表格数据之后，我们可以使用任意适用于表格数据的机器学习回归模型来进行预测，此处我们简单使用了lightgbm模型：

train_data = lgb.Dataset(X_train, label=y_train)

test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

def print_validation_result(env):

result = env.evaluation_result_list[-1]

print(f"[{env.iteration}] {result[1]}'s {result[0]}: {result[2]}")

params = {

"boosting_type": "gbdt",

"objective": "regression",

"metric": "root_mean_squared_error",

"max_depth": 7,

"learning_rate": 0.02,

"verbose": 0,

}

gbm = lgb.train(

params,

train_data,

num_boost_round=15000,

valid_sets=[test_data],

callbacks=[print_validation_result],

)

下面给出完整的代码并添加注释

import pandas as pd

# 读取训练数据和提交样本数据

df_original = pd.read_csv("C:/Users/32084/Desktop/train_data.csv")

n_original = df_original.shape[0] # 获取原始数据的行数

df_submit = pd.read_csv("C:/Users/32084/Desktop/sample_submission.csv")

# 合并数据并重置索引

df = pd.concat([df_original, df_submit], axis=0).reset_index(drop=True)

# 构建siRNA特征的函数

def siRNA_feat_builder(s: pd.Series, anti: bool = False):

name = "anti" if anti else "sense" # 根据参数设置名称

df = s.to_frame() # 将系列转换为DataFrame

df[f"feat_siRNA_{name}_seq_len"] = s.str.len() # 序列长度特征

# 前后位置的碱基特征

for pos in [0, -1]:

for c in list("AUGC"):

df[f"feat_siRNA_{name}_seq_{c}_{'front' if pos == 0 else 'back'}"] = (

s.str[pos] == c

)

# 不同的特定序列模式特征

df[f"feat_siRNA_{name}_seq_pattern_1"] = s.str.startswith("AA") & s.str.endswith("UU")

df[f"feat_siRNA_{name}_seq_pattern_2"] = s.str.startswith("GA") & s.str.endswith("UU")

df[f"feat_siRNA_{name}_seq_pattern_3"] = s.str.startswith("CA") & s.str.endswith("UU")

df[f"feat_siRNA_{name}_seq_pattern_4"] = s.str.startswith("UA") & s.str.endswith("UU")

df[f"feat_siRNA_{name}_seq_pattern_5"] = s.str.startswith("UU") & s.str.endswith("AA")

df[f"feat_siRNA_{name}_seq_pattern_6"] = s.str.startswith("UU") & s.str.endswith("GA")

df[f"feat_siRNA_{name}_seq_pattern_7"] = s.str.startswith("UU") & s.str.endswith("CA")

df[f"feat_siRNA_{name}_seq_pattern_8"] = s.str.startswith("UU") & s.str.endswith("UA")

df[f"feat_siRNA_{name}_seq_pattern_9"] = s.str[1] == "A"

df[f"feat_siRNA_{name}_seq_pattern_10"] = s.str[-2] == "A"

# GC含量特征

df[f"feat_siRNA_{name}_seq_pattern_GC_frac"] = (

s.str.count("G") + s.str.count("C")

) / s.str.len()

return df.iloc[:, 1:] # 返回特征列

# 对publication_id进行独热编码

df_publication_id = pd.get_dummies(df.publication_id)

df_publication_id.columns = [f"feat_publication_id_{c}" for c in df_publication_id.columns]

# 对gene_target_symbol_name进行独热编码

df_gene_target_symbol_name = pd.get_dummies(df.gene_target_symbol_name)

df_gene_target_symbol_name.columns = [f"feat_gene_target_symbol_name_{c}" for c in df_gene_target_symbol_name.columns]

# 对gene_target_ncbi_id进行独热编码

df_gene_target_ncbi_id = pd.get_dummies(df.gene_target_ncbi_id)

df_gene_target_ncbi_id.columns = [f"feat_gene_target_ncbi_id_{c}" for c in df_gene_target_ncbi_id.columns]

# 对gene_target_species进行独热编码

df_gene_target_species = pd.get_dummies(df.gene_target_species)

df_gene_target_species.columns = [f"feat_gene_target_species_{c}" for c in df_gene_target_species.columns]

# 标准化siRNA_duplex_id

siRNA_duplex_id_values = df.siRNA_duplex_id.str[3:-2].str.strip(".").astype("int")

siRNA_duplex_id_values = (siRNA_duplex_id_values - siRNA_duplex_id_values.min()) / (

siRNA_duplex_id_values.max() - siRNA_duplex_id_values.min()

)

df_siRNA_duplex_id = pd.DataFrame(siRNA_duplex_id_values)

# 对cell_line_donor进行独热编码

df_cell_line_donor = pd.get_dummies(df.cell_line_donor)

df_cell_line_donor.columns = [f"feat_cell_line_donor_{c}" for c in df_cell_line_donor.columns]

# 增加特定的细胞系特征

df_cell_line_donor["feat_cell_line_donor_hepatocytes"] = (

(df.cell_line_donor.str.contains("Hepatocytes")).fillna(False).astype("int")

)

df_cell_line_donor["feat_cell_line_donor_cells"] = (

df.cell_line_donor.str.contains("Cells").fillna(False).astype("int")

)

# 将siRNA浓度转换为DataFrame

df_siRNA_concentration = df.siRNA_concentration.to_frame()

# 对Transfection_method进行独热编码

df_Transfection_method = pd.get_dummies(df.Transfection_method)

df_Transfection_method.columns = [f"feat_Transfection_method_{c}" for c in df_Transfection_method.columns]

# 对Duration_after_transfection_h进行独热编码

df_Duration_after_transfection_h = pd.get_dummies(df.Duration_after_transfection_h)

df_Duration_after_transfection_h.columns = [

f"feat_Duration_after_transfection_h_{c}" for c in df_Duration_after_transfection_h.columns

]

# 合并所有特征

feats = pd.concat(

[

df_publication_id,

df_gene_target_symbol_name,

df_gene_target_ncbi_id,

df_gene_target_species,

df_siRNA_duplex_id,

df_cell_line_donor,

df_siRNA_concentration,

df_Transfection_method,

df_Duration_after_transfection_h,

siRNA_feat_builder(df.siRNA_sense_seq, False),

siRNA_feat_builder(df.siRNA_antisense_seq, True),

df.iloc[:, -1].to_frame(),

],

axis=1,

)

import lightgbm as lgb

from sklearn.model_selection import train_test_split

# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(

feats.iloc[:n_original, :-1],

feats.iloc[:n_original, -1],

test_size=0.25,

random_state=42,

)

# 构建LightGBM数据集

train_data = lgb.Dataset(X_train, label=y_train)

test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

# 打印验证结果的回调函数

def print_validation_result(env):

result = env.evaluation_result_list[-1]

print(f"[{env.iteration}] {result[1]}'s {result[0]}: {result[2]}")

# 设置LightGBM参数

params = {

"boosting_type": "gbdt",

"objective": "regression",

"metric": "root_mean_squared_error",

"max_depth": 7,

"learning_rate": 0.02,

"verbose": 0,

}

# 训练模型

gbm = lgb.train(

params,

train_data,

num_boost_round=20000,

valid_sets=[test_data],

callbacks=[print_validation_result],

)

# 预测结果

y_pred = gbm.predict(feats.iloc[n_original:, :-1])

# 保存预测结果到CSV文件

df_submit["mRNA_remaining_pct"] = y_pred

df_submit.to_csv("submission.csv", index=False)

重新调整参数进行修改改进不断提高分数： 

考虑处理缺失值和标准化以及早停法（正在尝试~）

思考体验

Task 2 详解解释了baseline的思路及其数据原理，更加深入了解数据特征工程的重要意义。同时又见到了第二期学习中的老朋友lightgbm，加深了理解。目前卡在上分瓶颈，期待进一步的学习~~

Task 3：特征工程进阶

生物学角度新特征

使用反义链与target gene序列的序列匹配结果作为特征来增强模型表现。在siRNA沉默target gene的过程中，RNA酶III家族的Dicer与TAR RNA结合蛋白和Argonaute（Ago）共同作用，产生长度为21–25个核苷酸的siRNA。siRNA做为RNA诱导沉默复合体（RISC）的组成部分，能够识别靶mRNA，从而达到沉默目标基因的作用。但是siRNA与靶mRNA的互补方式的不同意味着沉默机制的不同：siRNA与mRNA的3′非翻译区（UTR）结合，在Ago1、Ago3和Ago4的帮助下会导致翻译抑制；但如果siRNA与编码序列（CDS）完全互补，靶mRNA将被Ago2的内切核酸酶活性切割。而本比赛的预测目标是mRNA的保留水平，因此siRNA反义链与target gene的匹配程度，以及匹配位置，都会对预测目标产生影响。

  参考文献：

  Paddison PJ. RNA interference in mammalian cell systems. Curr Top Microbiol Immunol 2008; 320: 1–19. 12 Ji X.

  The mechanism of RNase III action: how dicer dices. Curr Top Microbiol Immunol 2008; 320: 99–116. 13

  Rivas FV, Tolia NH, Song J-J, Aragon JP, Liu J, Hannon GJ et al. Purified Argonaute2 and an siRNA form recombinant human RISC. Nat Struct Mol Biol 2005; 12: 340–349. 14

  Su H, Trombly MI, Chen J, Wang X. Essential and overlapping functions for mammalian Argonautes in microRNA silencing. Genes Dev 2009; 23: 304–317.

GC含量是siRNA效率中的一个重要且基本的参数，可以作为模型预测的特征。这是因为低GC含量会导致非特异性和较弱的结合，而高GC含量可能会阻碍siRNA双链在解旋酶和RISC复合体作用下的解旋。生物学研究人员曾经通过大量实验确定了siRNA的GC含量的可接受区间，有人提出过31.6%到57.9%这个区间，也有人提出过36%到52%这个区间。此外，也有研究者更深入地地探讨了这个问题，他们发现在反义链中，第2到第7个核苷酸和第8到第18个核苷酸的GC百分比分别为19%和52%是理想的。此外，功能性siRNA在第9到第14个核苷酸之间有一个不稳定区域（GC含量低于其他区域），被称为能量谷，这是选择siRNA的重要标准。这种内部的不稳定性通过在mRNA剪切过程中诱导最理想的构象，从而提高了RISC复合体的功能性。从上述生物学研究中我们可以发现，siRNA的GC含量，或者片段中特定位置的GC含量，对其沉默效率至关重要。

  参考文献：

  Reynolds A, Leake D, Boese Q, Scaringe S, Marshall WS, Khvorova A. Rational siRNA design for RNA interference. Nat Biotechnol 2004; 22: 326–330. 40.

  Ui‐Tei K, Naito Y, Takahashi F, Haraguchi T, Ohki‐Hamazaki H, Juni A et al. Guidelines for the selection of highly effective siRNA sequences for mammalian and chick RNA interference. Nucleic Acids Res 2004; 32: 936–948. 41

  Amarzguioui M, Prydz H. An algorithm for selection of functional siRNA sequences. Biochem Biophys Res Commun 2004; 316: 1050–1058.

  Khvorova A, Reynolds A, Jayasena SD. Functional siRNAs and miRNAs exhibit strand bias. Cell 2003; 115: 209–216.

将修饰过的碱基序列也进行编码，简单的编码方式是将带有修饰的核苷酸编码为和普通核苷酸不一样的输入向量，复杂的编码方式是将不同修饰在化学上的差异也加入模型中。siRNA上核苷酸的化学修饰对于siRNA发挥其功能至关重要。在siRNA治疗技术研发的早期阶段，siRNA药物都是未加修饰的，siRNA可以在体内介导基因沉默，但是可能会出现较差治疗效果和潜在的非靶向效应。化学修饰的siRNA，例如用2′-O-甲基（2′-OMe）或2′-甲氧乙基（2′-MOE）取代2′-OH，或用locked nucleic acid、unlocked nucleic acid或glycol nucleic acid取代某些核苷酸，可以有效抑制由siRNA引发的免疫刺激性内源免疫激活，增强活性和特异性，并减少非靶向诱导的毒性。根据核苷酸的自然结构，化学修饰可以施加在磷酸骨架、核糖部分或碱基上。通常，这些修饰会同时引入到siRNA中。例如，2′-OMe和磷硫酸酯（PS）修饰的结合有助于胆固醇结合的siRNA的系统性给药，并实现体内高效的基因沉默。从siRNA药物的研发经验来说，对siRNA的精确修饰可以提高其沉默效率、特异性和稳定性，并减少其毒性和免疫原性。

  参考文献：

  Ju¨rgen Soutschek, A. A. et al. Therapeutic silencing of an endogenous gene by systemic administration of modified siRNAs. nature432, 173–178 (2004).

  Khvorova, A. & Watts, J. K. The chemical evolution of oligonucleotide therapies of clinical utility. Nat. Biotechnol.35, 238–248 (2017).

代码实现 

新特征引入 

修饰siRNA构建特征

修饰siRNA序列进行n-gram的词频统计，同时也可对未修饰序列进行相同的操作。

<code>class GenomicTokenizer:

def __init__(self, ngram=5, stride=2):

# 初始化分词器，设置n-gram长度和步幅

self.ngram = ngram

self.stride = stride

def tokenize(self, t):

# 字符串变list

if isinstance(t, str):

t = list(t)

if self.ngram == 1:

# 如果n-gram长度为1，直接将序列转换为字符列表

toks = t

else:

# 否则，按照步幅对序列进行n-gram分词

toks = [t[i:i+self.ngram] for i in range(0, len(t), self.stride) if len(t[i:i+self.ngram]) == self.ngram]

# 如果最后一个分词长度小于n-gram，移除最后一个分词

if len(toks[-1]) < self.ngram:

toks = toks[:-1]

# sub list to str

toks = [''.join(x) for x in toks]

# 返回分词结果

return toks

class GenomicVocab:

def __init__(self, itos):

# 初始化词汇表，itos是一个词汇表列表

self.itos = itos

# 创建从词汇到索引的映射

self.stoi = {v: k for k, v in enumerate(self.itos)}

@classmethod

def create(cls, tokens, max_vocab, min_freq):

# 创建词汇表类方法

# 统计每个token出现的频率

freq = Counter(tokens)

# 选择出现频率大于等于min_freq的token，并且最多保留max_vocab个token

# itos = ['<pad>'] + [o for o, c in freq.most_common(max_vocab - 1) if c >= min_freq]

itos = [o for o, c in freq.most_common(max_vocab - 1) if c >= min_freq]

# 返回包含词汇表的类实例

return cls(itos)

def siRNA_feat_builder_substr(se, name, patterns):

# 创建一个空字典来存储特征

features = {}

for pattern in patterns:

try:

# escaped_pattern = re.escape(pattern) # 转义模式中的特殊字符

escaped_pattern = pattern

features[f"feat_{name}_seq_pattern_{escaped_pattern}"] = se.str.count(escaped_pattern)

except re.error as e:

print(f"Error in pattern {pattern}: {e}")

# 将字典转换为DataFrame

feature_df = pd.DataFrame(features)

return feature_df

siRNA序列与target序列对比

siRNA与target序列的结合能力是一个很重要的特征，其中两者的序列比对score可作为对这个特征的定量化描述（测试了500个数据）

参考：https://biopython.org/docs/1.76/api/Bio.pairwise2.html

 lgm优化

低Remaining范围样本高权重

<code>weight_ls = np.array(feats['mRNA_remaining_pct'].apply(lambda x:2 if ((x<=30)and(x>=0)) else 1))

使用官方评价指标作为损失函数

由原来的root_mean_squared_error评价指标被替换为更加复杂的官方评价分数，具体公式为:

<code># calculate_metrics函数用于计算评估指标

def calculate_metrics(preds, data, threshold=30):

y_pred = preds

y_true = data.get_label()

mae = np.mean(np.abs(y_true - y_pred))

# if mae < 0: mae = 0

# elif mae >100: mae = 100

y_true_binary = ((y_true <= threshold) & (y_true >= 0)).astype(int)

y_pred_binary = ((y_pred <= threshold) & (y_pred >= 0)).astype(int)

mask = (y_pred >= 0) & (y_pred <= threshold)

range_mae = (

mean_absolute_error(y_true[mask], y_pred[mask]) if np.sum(mask) > 0 else 100

)

# if range_mae < 0: range_mae = 0

# elif range_mae >100: range_mae = 100

# precision = precision_score(y_true_binary, y_pred_binary, average="binary")code>

# recall = recall_score(y_true_binary, y_pred_binary, average="binary")code>

if np.sum(y_pred_binary) > 0:

precision = (np.array(y_pred_binary) & y_true_binary).sum()/np.sum(y_pred_binary)

else:

precision = 0

if np.sum(y_true_binary) > 0:

recall = (np.array(y_pred_binary) & y_true_binary).sum()/np.sum(y_true_binary)

else:

recall = 0

if precision + recall == 0:

f1 = 0

else:

f1 = 2 * precision * recall / (precision + recall)

score = (1 - mae / 100) * 0.5 + (1 - range_mae / 100) * f1 * 0.5

return "custom_score", score, True # True表示分数越高越好

自适应学习率