已经获取2个RNA的特征矩阵 ，每个矩阵维度是1307×48，一个矩阵是正样本数据标签为1 ，另一个矩阵是负样本数据标签为0 构建一个包含3层全连接层的深度神经网络，用该神经网络预测该数据是正样本还是负样本（用pytorch实现） 其中，70%为训练集，10%为验证集，20%的数据为测试集

以下是使用PyTorch实现的代码，包括数据预处理、构建神经网络模型、训练模型、评估模型等步骤：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
from sklearn.model_selection import train_test_split

# 加载数据
data1 = torch.load('data1.pt')
data2 = torch.load('data2.pt')
label1 = torch.ones(data1.shape[0], 1)    # 正样本标签为1
label2 = torch.zeros(data2.shape[0], 1)   # 负样本标签为0
data = torch.cat((data1, data2), dim=0)   # 拼接数据
label = torch.cat((label1, label2), dim=0) # 拼接标签

# 划分训练集、验证集、测试集
X_train, X_test, y_train, y_test = train_test_split(data, label, test_size=0.2, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.125, random_state=42)

# 转换为TensorDataset
train_data = TensorDataset(X_train, y_train)
val_data = TensorDataset(X_val, y_val)
test_data = TensorDataset(X_test, y_test)

# 构建DataLoader
train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
val_loader = DataLoader(val_data, batch_size=32, shuffle=True)
test_loader = DataLoader(test_data, batch_size=32, shuffle=True)

# 定义神经网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(1307*48, 256)    # 输入层
        self.fc2 = nn.Linear(256, 64)         # 隐藏层
        self.fc3 = nn.Linear(64, 1)           # 输出层
        self.relu = nn.ReLU()                 # 激活函数

    def forward(self, x):
        x = x.view(-1, 1307*48)               # 展开数据
        x = self.relu(self.fc1(x))            # 输入层
        x = self.relu(self.fc2(x))            # 隐藏层
        x = self.fc3(x)                       # 输出层
        return x

# 实例化模型、损失函数、优化器
model = Net()
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(50):
    train_loss = 0.0
    val_loss = 0.0
    
    # 训练模式
    model.train()
    for data, label in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()*data.size(0)
    train_loss /= len(train_loader.dataset)
    
    # 验证模式
    model.eval()
    for data, label in val_loader:
        with torch.no_grad():
            output = model(data)
            loss = criterion(output, label)
            val_loss += loss.item()*data.size(0)
    val_loss /= len(val_loader.dataset)
    
    print('Epoch: {}, Training Loss: {:.4f}, Validation Loss: {:.4f}'.format(epoch+1, train_loss, val_loss))

# 测试模型
model.eval()
with torch.no_grad():
    test_loss = 0.0
    correct = 0
    total = 0
    for data, label in test_loader:
        output = model(data)
        loss = criterion(output, label)
        test_loss += loss.item()*data.size(0)
        pred = torch.round(torch.sigmoid(output))
        correct += (pred == label).sum().item()
        total += label.size(0)
    test_loss /= len(test_loader.dataset)
    accuracy = correct/total
    print('Test Loss: {:.4f}, Accuracy: {:.4f}'.format(test_loss, accuracy))

注：本代码仅供参考，具体实现方式可能因数据集和任务需求而异。