【万字详文介绍】:迭代扩张卷积神经网络(IDCNN)

news2024/11/6 1:26:26

💗💗💗欢迎来到我的博客,你将找到有关如何使用技术解决问题的文章,也会找到某个技术的学习路线。无论你是何种职业,我都希望我的博客对你有所帮助。最后不要忘记订阅我的博客以获取最新文章,也欢迎在文章下方留下你的评论和反馈。我期待着与你分享知识、互相学习和建立一个积极的社区。谢谢你的光临,让我们一起踏上这个知识之旅!
请添加图片描述

文章目录

  • 🍀引言
  • 🍀IDCNN概述
    • 🍀特点与优势
    • 🍀网络结构
  • 🍀实践IDCNN
    • 🍀环境准备
    • 🍀数据集选择
    • 🍀加载和预处理数据
    • 🍀准备训练和测试数据
    • 🍀 定义 IDCNN 模型
    • 🍀模型训练
    • 🍀模型评估
  • 🍀完整的模型代码(示例跑着玩)
  • 🍀完整的模型代码(CoNLL-2003数据集)
  • 🍀完整的模型代码(CoNLL-2003数据集)(CNN版)
  • 🍀对比实验(CoNLL-2003数据集)
  • 🍀结论
  • 🍀参考文献

🍀引言

在深度学习的快速发展中,卷积神经网络(CNN)在图像处理领域表现卓越。然而,处理序列数据(如语音或文本)时,IDCNN(空洞卷积网络)作为一种新兴的模型,展现出优越的性能。本博客将介绍IDCNN的基本概念及其应用实践,帮助您理解并实践这一高效的模型。


🍀IDCNN概述

IDCNN,即空洞卷积网络(Iterated Dilated Convolutional Neural Network),是一种结合了深度卷积层和序列数据处理的新型模型。传统的RNN模型在处理长序列数据时易受梯度消失和梯度爆炸的影响,导致计算效率低下。而IDCNN通过空洞卷积的结构设计,能够在保持高效计算的同时,捕捉到序列中的长距离依赖特性,非常适合用于自然语言处理和序列数据分析等任务。

🍀特点与优势

IDCNN的独特之处在于其网络结构设计,主要体现在以下几个方面:

长距离依赖性:IDCNN利用空洞卷积能够在不增加计算量的情况下扩展感受野,有效捕捉序列数据中的长距离依赖。
高效性:相较于传统的RNN模型,IDCNN在计算上更为高效。它避免了循环结构带来的顺序依赖问题,因此可以实现并行计算。
灵活性:IDCNN支持增量学习,可在数据逐步增多的情况下动态更新模型结构和参数,适应更多样化的应用场景。## 🍀网络结构

  • 长距离依赖性:IDCNN能够有效捕捉序列数据中的长距离依赖。
  • 高效性:与传统的RNN相比,IDCNN在计算上更为高效,适合并行处理。
  • 灵活性:支持增量学习,可以动态更新模型。

🍀网络结构

IDCNN的网络结构通常由多个卷积层和激活函数组成。这些卷积层采用空洞卷积的形式,通过逐层堆叠和扩展感受野的方式,捕捉输入数据中的时序特征。同时,IDCNN可以灵活地与其他网络模块(如CRF层)结合,以实现更精细的序列标注任务。

🍀实践IDCNN

🍀环境准备

在开始构建IDCNN模型前,首先需要配置必要的深度学习环境。常用的Python库包括:

  • PyTorch:用于构建深度学习模型。
  • scikit-learn:提供数据处理和评估的基本工具。
  • NumPy:用于数据处理和矩阵运算。
  • 确保以上库的安装,可以使用以下命令:
pip install torch scikit-learn numpy

🍀数据集选择

IDCNN可以应用于多种序列数据任务中,如文本序列标注、语音识别等。在本文中,我们以自然语言处理中的命名实体识别(NER)任务为例,选择经典的CoNLL-2003数据集。该数据集包含英语句子的序列标注,标签包括人物、地点、组织等实体类型。

🍀加载和预处理数据

加载数据集

dataset = load_dataset("conll2003", trust_remote_code=True)

这里我们加载了 CoNLL-2003 数据集,它是一个常用于命名实体识别(NER)任务的数据集。trust_remote_code=True 参数允许 datasets 库执行远程代码,这在加载该数据集时是必须的。


标签编码

label_encoder = LabelEncoder()
label_encoder.fit([label for labels in dataset['train']['ner_tags'] for label in labels])
num_labels = len(label_encoder.classes_)

这里使用 scikit-learn 中的 LabelEncoder 将 NER 标签(即标注)转换为整数 ID,称为标签编码。num_labels 表示标签的种类数,用于定义模型的输出维度。

构建词汇表

word_to_index = {"<PAD>": 0}
for tokens in dataset["train"]["tokens"]:
    for token in tokens:
        if token not in word_to_index:
            word_to_index[token] = len(word_to_index)

我们通过 word_to_index 字典为每个唯一单词分配一个整数 ID。特殊标记 “” 用于填充短句子,它的 ID 为 0。这个词汇表帮助我们将单词转换为整数索引。

数据预处理函数

def preprocess_data(split):
    sentences = []
    labels = []
    max_len = 50  # 假设每个句子都填充或截断到长度为50

    for item in dataset[split]:
        tokens = item['tokens']
        ner_tags = item['ner_tags']

        token_ids = [word_to_index.get(token, 0) for token in tokens]
        label_ids = label_encoder.transform(ner_tags)

        if len(token_ids) > max_len:
            token_ids = token_ids[:max_len]
            label_ids = label_ids[:max_len]
        else:
            token_ids = token_ids + [0] * (max_len - len(token_ids))
            label_ids = list(label_ids) + [0] * (max_len - len(label_ids))

        sentences.append(token_ids)
        labels.append(label_ids)

    return torch.tensor(sentences), torch.tensor(labels)

preprocess_data 函数的主要功能是:

  • 使用 word_to_index 将单词转换为整数 ID。
  • 使用 label_encoder 将标签转换为整数 ID。
  • 将每个句子填充或截断至固定长度 max_len(这里假设为 50),确保输入尺寸一致。

🍀准备训练和测试数据

X_train, y_train = preprocess_data("train")
X_test, y_test = preprocess_data("test")

train_dataset = TensorDataset(X_train, y_train)
test_dataset = TensorDataset(X_test, y_test)

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=16)

我们对训练和测试集分别进行了预处理,并创建了 TensorDataset 对象。然后用 DataLoader 包装这些数据集,以便在训练过程中能够方便地进行批量处理和随机打乱。

🍀 定义 IDCNN 模型

class IDCNN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(IDCNN, self).__init__()
        self.embedding = nn.Embedding(input_dim, hidden_dim)
        self.conv1 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=1, padding=1)
        self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=2, padding=2)
        self.conv3 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=4, padding=4)
        self.fc = nn.Linear(hidden_dim, output_dim)

IDCNN 模型(膨胀卷积网络)定义了一个嵌入层和多个卷积层,其中卷积层使用不同的膨胀率(dilation)来捕捉不同长度的特征。

  • self.embedding:嵌入层,将输入的单词索引映射到一个 hidden_dim 维度的嵌入向量。
  • self.conv1、self.conv2、self.conv3:三层卷积,分别具有不同的膨胀率(1、2 和 4),以捕捉不同的上下文信息。
  • self.fc:全连接层,将卷积层的输出映射到标签空间,输出维度为 output_dim。

前向传播

def forward(self, x):
    x = self.embedding(x)  # (batch_size, sequence_length, hidden_dim)
    x = x.permute(0, 2, 1)  # 转换维度以适应Conv1d
    x = torch.relu(self.conv1(x))
    x = torch.relu(self.conv2(x))
    x = torch.relu(self.conv3(x))
    x = x.permute(0, 2, 1)  # 转换维度以适应全连接层
    x = self.fc(x)
    return x

前向传播过程中:

  • 使用嵌入层将输入转换为嵌入向量。
  • 使用三层膨胀卷积提取特征。
  • 使用全连接层将特征映射到输出空间。

🍀模型训练

for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        outputs = outputs.view(-1, output_dim)
        labels = labels.view(-1)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(train_loader):.4f}")

在训练过程中:

  • optimizer.zero_grad() 清除上一步的梯度。
  • outputs 将模型输出调整为 (batch_size * sequence_length, output_dim) 以便于计算损失。
  • oss.backward() 反向传播计算梯度。
  • optimizer.step() 更新模型参数。
  • 每个 epoch 结束后打印平均损失。

🍀模型评估

model.eval()
all_preds = []
all_labels = []

with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        outputs = outputs.view(-1, output_dim)
        _, preds = torch.max(outputs, dim=1)
        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(labels.view(-1).cpu().numpy())

在评估阶段,关闭梯度计算以提高效率。我们获取每个输入的预测标签,并将其保存到 all_preds 中,用于后续的评估。

删除填充部分

true_labels = [label for label, pred in zip(all_labels, all_preds) if label != 0]
true_preds = [pred for label, pred in zip(all_labels, all_preds) if label != 0]

由于使用了填充,我们需要将填充的标签去除,仅保留真实标签。

输出分类报告

print(classification_report(true_labels, true_preds, target_names=[str(label) for label in label_encoder.classes_], zero_division=0))

使用 classification_report 打印分类报告,显示每个标签的精确度、召回率和 F1 分数。这些指标帮助我们评估模型的表现。

这样整个代码就完成了。这个流程实现了一个简单的命名实体识别模型,并在 CoNLL-2003 数据集上进行训练和评估,接下来我会将完整的代码放到下面,并在结尾附上使用CNN的评估结果供大家对比参考~

🍀完整的模型代码(示例跑着玩)

下面使用的数据是自定义的数据

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import classification_report
import numpy as np

# 定义IDCNN模型
class IDCNN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(IDCNN, self).__init__()
        # 三层空洞卷积,使用不同的dilation值
        self.conv1 = nn.Conv1d(input_dim, hidden_dim, kernel_size=3, dilation=1, padding=1)
        self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=2, padding=2)
        self.conv3 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=4, padding=4)
        # 全连接层,用于输出最终的类别
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # 输入x的维度为 (batch_size, input_dim, sequence_length)
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        # 对卷积输出维度进行平均池化,减少维度
        x = x.mean(dim=2)
        x = self.fc(x)
        return x

# 生成一些假数据,模拟序列标注任务
# 假设输入维度为128,隐藏层维度为256,输出类别数为10
input_dim = 128
hidden_dim = 256
output_dim = 10
sequence_length = 50
batch_size = 16
num_epochs = 10

# 创建随机的数据和标签
X_train = torch.randn(1000, input_dim, sequence_length)  # 1000个样本
y_train = torch.randint(0, output_dim, (1000,))          # 每个样本对应一个标签
X_test = torch.randn(200, input_dim, sequence_length)    # 200个测试样本
y_test = torch.randint(0, output_dim, (200,))            # 每个测试样本对应一个标签

# 创建数据加载器
train_dataset = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dataset = TensorDataset(X_test, y_test)
test_loader = DataLoader(test_dataset, batch_size=batch_size)

# 初始化模型、损失函数和优化器
model = IDCNN(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(num_epochs):
    model.train()
    for inputs, labels in train_loader:
        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")

# 模型评估
model.eval()
all_preds = []
all_labels = []

with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, preds = torch.max(outputs, dim=1)
        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(labels.cpu().numpy())

# 输出分类报告
print(classification_report(all_labels, all_preds, target_names=[f"Class {i}" for i in range(output_dim)], zero_division=1))

运行结果如下:
在这里插入图片描述

🍀完整的模型代码(CoNLL-2003数据集)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import classification_report
from datasets import load_dataset
from sklearn.preprocessing import LabelEncoder
import numpy as np

# 1. 加载并预处理数据

# 加载CoNLL-2003数据集,添加 trust_remote_code=True 参数
dataset = load_dataset("conll2003", trust_remote_code=True)


# 标签编码
label_encoder = LabelEncoder()
label_encoder.fit([label for labels in dataset['train']['ner_tags'] for label in labels])
num_labels = len(label_encoder.classes_)

# 构建词汇表(为了演示简单化,实际应用中建议使用预训练词向量,如GloVe或BERT)
word_to_index = {"<PAD>": 0}
for tokens in dataset["train"]["tokens"]:
    for token in tokens:
        if token not in word_to_index:
            word_to_index[token] = len(word_to_index)


# 数据预处理函数
def preprocess_data(split):
    sentences = []
    labels = []
    max_len = 50  # 假设每个句子都填充或截断到长度为50

    for item in dataset[split]:
        tokens = item['tokens']
        ner_tags = item['ner_tags']

        # 将tokens转换为词ID,labels转换为标签ID
        token_ids = [word_to_index.get(token, 0) for token in tokens]  # 简单示例,使用词ID
        label_ids = label_encoder.transform(ner_tags)

        # 确保 token_ids 和 label_ids 的长度相同
        if len(token_ids) > max_len:
            token_ids = token_ids[:max_len]
            label_ids = label_ids[:max_len]
        else:
            token_ids = token_ids + [0] * (max_len - len(token_ids))
            label_ids = list(label_ids) + [0] * (max_len - len(label_ids))

        sentences.append(token_ids)
        labels.append(label_ids)

    return torch.tensor(sentences), torch.tensor(labels)


# 准备训练和测试数据
X_train, y_train = preprocess_data("train")
X_test, y_test = preprocess_data("test")

train_dataset = TensorDataset(X_train, y_train)
test_dataset = TensorDataset(X_test, y_test)

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=16)


# 2. 定义IDCNN模型
class IDCNN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(IDCNN, self).__init__()
        self.embedding = nn.Embedding(input_dim, hidden_dim)
        self.conv1 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=1, padding=1)
        self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=2, padding=2)
        self.conv3 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=4, padding=4)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.embedding(x)  # (batch_size, sequence_length, hidden_dim)
        x = x.permute(0, 2, 1)  # 转换维度以适应Conv1d
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        x = x.permute(0, 2, 1)  # 转换维度以适应全连接层
        x = self.fc(x)
        return x


# 参数设置
input_dim = len(word_to_index)
hidden_dim = 128
output_dim = num_labels
num_epochs = 5

# 初始化模型、损失函数和优化器
model = IDCNN(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 3. 训练模型
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        outputs = outputs.view(-1, output_dim)
        labels = labels.view(-1)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(train_loader):.4f}")

# 4. 模型评估
model.eval()
all_preds = []
all_labels = []

with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        outputs = outputs.view(-1, output_dim)
        _, preds = torch.max(outputs, dim=1)
        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(labels.view(-1).cpu().numpy())

# 删除填充部分的标签和预测
true_labels = [label for label, pred in zip(all_labels, all_preds) if label != 0]
true_preds = [pred for label, pred in zip(all_labels, all_preds) if label != 0]

# 输出分类报告
print(classification_report(true_labels, true_preds, target_names=[str(label) for label in label_encoder.classes_], zero_division=0))

运行代码如下:

在这里插入图片描述

🍀完整的模型代码(CoNLL-2003数据集)(CNN版)

要将模型从 IDCNN(膨胀卷积神经网络)更改为 普通的CNN,只需去掉膨胀率设置,将卷积层的 dilation 参数设置为 1(即默认值)。普通的CNN可以通过堆叠多个卷积层来实现。

  • 我们将 IDCNN 类改名为 CNN。
  • 在每个卷积层(conv1、conv2 和 conv3)中,去掉了 dilation 参数(默认为1),并保持了 padding=1。这样,每个卷积层会像普通的卷积操作那样,只关注相邻元素。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import classification_report
from datasets import load_dataset
from sklearn.preprocessing import LabelEncoder
import numpy as np

# 1. 加载并预处理数据

# 加载CoNLL-2003数据集,添加 trust_remote_code=True 参数
dataset = load_dataset("conll2003", trust_remote_code=True)

# 标签编码
label_encoder = LabelEncoder()
label_encoder.fit([label for labels in dataset['train']['ner_tags'] for label in labels])
num_labels = len(label_encoder.classes_)

# 构建词汇表(为了演示简单化,实际应用中建议使用预训练词向量,如GloVe或BERT)
word_to_index = {"<PAD>": 0}
for tokens in dataset["train"]["tokens"]:
    for token in tokens:
        if token not in word_to_index:
            word_to_index[token] = len(word_to_index)

# 数据预处理函数
def preprocess_data(split):
    sentences = []
    labels = []
    max_len = 50  # 假设每个句子都填充或截断到长度为50

    for item in dataset[split]:
        tokens = item['tokens']
        ner_tags = item['ner_tags']

        # 将tokens转换为词ID,labels转换为标签ID
        token_ids = [word_to_index.get(token, 0) for token in tokens]  # 简单示例,使用词ID
        label_ids = label_encoder.transform(ner_tags)

        # 确保 token_ids 和 label_ids 的长度相同
        if len(token_ids) > max_len:
            token_ids = token_ids[:max_len]
            label_ids = label_ids[:max_len]
        else:
            token_ids = token_ids + [0] * (max_len - len(token_ids))
            label_ids = list(label_ids) + [0] * (max_len - len(label_ids))

        sentences.append(token_ids)
        labels.append(label_ids)

    return torch.tensor(sentences), torch.tensor(labels)

# 准备训练和测试数据
X_train, y_train = preprocess_data("train")
X_test, y_test = preprocess_data("test")

train_dataset = TensorDataset(X_train, y_train)
test_dataset = TensorDataset(X_test, y_test)

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=16)

# 2. 定义普通CNN模型
class CNN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(CNN, self).__init__()
        self.embedding = nn.Embedding(input_dim, hidden_dim)
        # 普通卷积网络,不使用膨胀卷积
        self.conv1 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1)
        self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1)
        self.conv3 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.embedding(x)  # (batch_size, sequence_length, hidden_dim)
        x = x.permute(0, 2, 1)  # 转换维度以适应Conv1d
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        x = x.permute(0, 2, 1)  # 转换维度以适应全连接层
        x = self.fc(x)
        return x

# 参数设置
input_dim = len(word_to_index)
hidden_dim = 128
output_dim = num_labels
num_epochs = 5

# 初始化普通CNN模型、损失函数和优化器
model = CNN(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 3. 训练模型
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        outputs = outputs.view(-1, output_dim)
        labels = labels.view(-1)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(train_loader):.4f}")

# 4. 模型评估
model.eval()
all_preds = []
all_labels = []

with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        outputs = outputs.view(-1, output_dim)
        _, preds = torch.max(outputs, dim=1)
        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(labels.view(-1).cpu().numpy())

# 删除填充部分的标签和预测
true_labels = [label for label, pred in zip(all_labels, all_preds) if label != 0]
true_preds = [pred for label, pred in zip(all_labels, all_preds) if label != 0]

# 输出分类报告
print(classification_report(true_labels, true_preds, target_names=[str(label) for label in label_encoder.classes_], zero_division=0))

运行结果如下:
在这里插入图片描述

🍀对比实验(CoNLL-2003数据集)

模型PrecisionRecallF1-Score
CNN0.830.490.60
IDCNN0.820.530.64

从结果来看,IDCNN 的召回率和 F1-Score 略优于 CNN,显示出 IDCNN 模型在捕捉命名实体的特征方面具有一定优势。

🍀结论

IDCNN作为一种新兴的序列数据处理模型,凭借其高效性和灵活性在自然语言处理、语音识别等领域展现出广泛的应用潜力。通过空洞卷积的结构设计,IDCNN可以在保证计算效率的同时捕捉长距离依赖关系,为序列标注任务提供了有效的解决方案。

🍀参考文献

  1. Yu, F., & Koltun, V. (2016). Multi-Scale Context Aggregation by Dilated Convolutions. arXiv preprint arXiv:1511.07122.
  2. Ma, J., & Hovy, E. (2016). End-to-end sequence labeling via bi-directional LSTM-CNNs-CRF. arXiv preprint arXiv:1603.01354.
  3. He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 770-778).

请添加图片描述

挑战与创造都是很痛苦的,但是很充实。

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

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

相关文章

Oracle OCP认证考试考点详解082系列12

题记&#xff1a; 本系列主要讲解Oracle OCP认证考试考点&#xff08;题目&#xff09;&#xff0c;适用于19C/21C,跟着学OCP考试必过。 56. 第56题&#xff1a; 题目 解析及答案&#xff1a; 关于企业管理器&#xff08;EM&#xff09;Express&#xff0c;以下哪两个陈述是…

任务:拟合曲面

3d 要拟合粗的蓝色曲面&#xff0c;剩下三条线是在3个平面的投影 1 2 3 4d

Python世界:自动化办公Word之批量替换文本生成副本

Python世界&#xff1a;自动化办公Word之批量替换文本生成副本 任务背景编码思路代码实现相关参考 任务背景 为提高办公效率&#xff0c;用python试手了一个word任务&#xff0c;要求如下&#xff1a; 给你一个基础word文档A&#xff0c;格式为docx&#xff0c;名字为&#xf…

如何检查雷池社区版 WAF 是否安装成功?

容器运行状态检查&#xff1a; 使用命令行检查&#xff1a;打开终端&#xff0c;连接到安装雷池的服务器。运行 docker ps 命令&#xff0c;查看是否有与雷池相关的容器正在运行。 如果能看到类似 safeline-mgt、safeline-tengine 等相关容器&#xff0c;并且状态为 Up&#x…

青少年编程能力等级测评CPA Python编程(一级)

青少年编程能力等级测评CPA Python编程(一级) &#xff08;考试时间90分钟&#xff0c;满分100分&#xff09; 一、单项选择题&#xff08;共20题&#xff0c;每题3.5分&#xff0c;共70分&#xff09; 下列语句的输出结果是&#xff08; &#xff09;。 print(35*2) A&a…

java学习2

一、什么是方法 方法&#xff08;method&#xff09;是程序中最小的执行单元 重复的代码、具有独立功能的代码可以抽取到方法中&#xff1b;提高代码的复用性和可维护性。 二、方法的格式 1.方法的格式定义&#xff1a; 最简单的方法定义 调用&#xff1a;playGame(); 带…

蓝牙资讯|苹果AirPods Pro 2推出听力测试、助听器和听力保护等功能

苹果推送iOS 18.1 系统版本更新&#xff0c;AirPods Pro 2 用户也在 iOS 18.1 中获得了强大的新功能。 运行固件 7B19 的 AirPods Pro 2 用户&#xff0c;搭配 iOS 18.1 系统的 iPhone&#xff0c;将获得三项强大的听力健康功能&#xff1a;听力测试、助听器和听力保护。 听力…

【学习日记】Anaconda的安装与使用-小白大学生

目录 日记说明 解压安装&#xff1a; 配置 使用 日记说明 作者是个大学生 这个专栏主要收集课时常用的软件 以及女朋友上课用的软件的教程 所有安装包可以私聊我获取 免费 提前清除已有python环境 windows11 Anaconda-2024.02 垃圾话&#xff1a; Anaconda 是全球领先的数…

内网项目,maven本地仓库离线打包,解决Cannot access central in offline mode?

背景&#xff1a; 内网项目打包&#xff0c;解决Cannot access central in offline mode? 1、修改maven配置文件&#xff1a; localRepository改为本地仓库位置 <localRepository>D:\WorkSpace\WorkSoft\maven-repository\iwhalecloud-repository\business</loca…

教你怎样搭建自动化测试框架?

&#x1f345; 点击文末小卡片&#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 最近好多小伙伴都在说接口自动化测试&#xff0c;那么究竟什么是接口自动化测试呢&#xff1f;让我们一起往下看就知道了&#xff0c;首先我们得先弄清楚下面这…

反转链表.

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a; 输入&am…

数列分块入门

本期是数列分块入门。其中的大部分题目来自hzwer在LOJ上提供的数列分块入门系列。 Blog:here (其实是对之前分块的 blog 的整理补充) sto hzwer orz %%% [转载] ---------------------------------------------------------------------------------…

基于SpringBoot+Gpt个人健康管家管理系统【提供源码+答辩PPT+参考文档+项目部署】

作者简介&#xff1a;✌CSDN新星计划导师、Java领域优质创作者、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行前辈交流。✌ 主要内容&#xff1a;&#x1f31f;Java项目、Python项目、前端项目、PHP、ASP.NET、人工智能…

苍穹外卖day-01

后端环境搭建 创建git仓库 提交代码 创建gitee远程仓库 开始连接远程仓库 运行sql文件&#xff0c;创建数据库。这里选取的可视化工具是navicat 编译一下项目 运行项目 登录的账号和密码在数据库中的emploee表中 退出前端界面登录后再重新登录&#xff0c;可以从后台清晰看到前…

【Docker故障处理】Ubuntu系统下tab键无法补全问题解决

【Docker故障处理】Ubuntu系统下tab键无法补全问题解决 一、环境介绍1.1 本地环境规划1.2 本次实践说明二、故障现象三、故障分析3.1 可能的原因3.2 排错思路四、故障处理4.1 安装bash-completion4.2 下载补全脚本4.3 配置永久生效五、测试tab键补全六、总结一、环境介绍 1.1 …

若依框架-添加测试类-最新

1、在【ruoyi-admin】的pom.xml下添加依赖 <!-- 单元测试--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-test</artifactId><scope>test</scope></dependency><dependency>…

CSS基础概念:什么是 CSS ? CSS 的组成

什么是 CSS&#xff1f; CSS&#xff08;层叠样式表&#xff0c;Cascading Style Sheets&#xff09;是一种用于控制网页外观的样式表语言。通过定义样式规则&#xff0c;CSS 可以指定 HTML 页面中各个元素的显示方式&#xff0c;包括颜色、布局、字体、间距等。 与 HTML 专注…

解密RFID技术提升应急消防管理效率的过程

一、部署RFID消防应急解决策略的具体步骤 &#xff08;1&#xff09;需求探讨与战略规划阶段 深入探究&#xff1a;全面、深刻地理解消防领域在资源分配、人员跟踪、应急救援等方面的实际需求。与消防机构紧密合作&#xff0c;共同确定RFID技术的应用提升和具体实施范围。 细…

国内短剧源码短剧系统搭建小程序部署H5、APP打造短剧平台

​在当今的互联网时代&#xff0c;短剧作为一种新兴的娱乐形式&#xff0c;受到了越来越多用户的喜爱。为了提供更好的用户体验和满足用户需求&#xff0c;一个好的短剧系统需要具备多元化的功能和优质的界面设计。 本文将介绍国内短剧源码短剧系统搭建小程序部署H5、APP所需的…

使用docker安装zlmediakit服务(zlm)

zlmediakit安装 zlmediakit安装需要依赖环境和系统配置&#xff0c;所以采用docker的方式来安装不容易出错。 docker pull拉取镜像(最新) docker pull zlmediakit/zlmediakit:master然后先运行起来 sudo docker run -d -p 1935:1935 -p 80:80 -p 8554:554 -p 10000:10000 -p …