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

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

文章目录

  • 🍀引言
  • 🍀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  # 假设每个句子都填充或截断到长度为50for 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)  # 转换维度以适应Conv1dx = 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 = 0for 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  # 假设每个句子都填充或截断到长度为50for item in dataset[split]:tokens = item['tokens']ner_tags = item['ner_tags']# 将tokens转换为词ID,labels转换为标签IDtoken_ids = [word_to_index.get(token, 0) for token in tokens]  # 简单示例,使用词IDlabel_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)  # 转换维度以适应Conv1dx = 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 = 0for 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  # 假设每个句子都填充或截断到长度为50for item in dataset[split]:tokens = item['tokens']ner_tags = item['ner_tags']# 将tokens转换为词ID,labels转换为标签IDtoken_ids = [word_to_index.get(token, 0) for token in tokens]  # 简单示例,使用词IDlabel_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)  # 转换维度以适应Conv1dx = 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 = 0for 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.rhkb.cn/news/464836.html

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

相关文章

2-Ubuntu/Windows系统启动盘制作

学习目标&#xff1a; 掌握使用Win32DiskImager、Rufus等工具制作系统启动盘的基本步骤。独立将ISO镜像文件写入USB闪存驱动器&#xff0c;确保在需要时顺利安装或修复系统。通过学习如何选择正确的源文件和目标驱动器&#xff0c;理解启动盘的使用场景和注意事项&#xff0c;…

简介Voronoi图Voronoi Diagrams

这是计算机的经典算法。 问题引入 倘若一张大白纸上有很多三角点&#xff0c;掉进去一个五星点&#xff0c;问&#xff0c;哪个三角离着五星最近&#xff1f;简单&#xff0c;算距离呗&#xff0c;这个五星到其他所有三角点的距离&#xff0c;找到最小的那个就行。 若掉进去…

【进阶sql】复杂sql收集及解析【mysql】

开发时会出现&#xff0c;必须写一些较复杂sql的场景 可能是给会sql的客户 提供一些统计sql 或是临时需要统计数据信息但是 开发一个统计功能有来不及的情况 也可能是报表系统组件 只支持 sql统计的情况 特地记录下这些sql 作为积累 substring 截取查询出的字符串&#xff…

SLF4J: Failed to load class “org.slf4j.impl.StaticLoggerBinder“

SLF4J常见问题 导入依赖&#xff1a; <dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version> </dependency> <dependency><groupId>org.slf4j</groupId><arti…

002-Kotlin界面开发之Kotlin旋风之旅

Kotlin旋风之旅 Compose Desktop中哪些Kotlin知识是必须的&#xff1f; 在学习Compose Desktop中&#xff0c;以下Kotlin知识是必须的&#xff1a; 基础语法&#xff1a;包括变量声明、数据类型、条件语句、循环等。面向对象编程&#xff1a;类与对象、继承、接口、抽象类等。…

RSTP的工作过程

RSTP简介&#xff1a; 生成树协议&#xff08;STP&#xff09;用于在网络中防止环路产生&#xff0c;但 STP 的收敛速度较慢。 RSTP&#xff08;Rapid Spanning Tree Protocol &#xff09;快速生成树协议&#xff1a;RSTP 是对 STP 的改进&#xff0c;它能在网络拓扑发生变化…

【IEEE出版 | EI稳定检索】2024智能机器人与自动控制国际学术会议 (IRAC 2024,11月29-12月1日)

2024智能机器人与自动控制国际学术会议 &#xff08;IRAC 2024&#xff09; 2024 International Conference on Intelligent Robotics and Automatic Control 官方信息 会议官网&#xff1a;www.icirac.org 2024 International Conference on Intelligent Robotics and Autom…

nginx 搭建网站

1.查看防火墙状态systemctl status firewalld 2.getenforce 3.安装nginx yum install nginx -y 4.网站信息 echo "welcome to yinchuankejixuanyuan" > /usr/share/nginx/html/index.html 5.查看命令状态 nginx -t 6.重启 systemctl restart nginx

从0开始搭建一个生产级SpringBoot2.0.X项目(八)SpringBoot 使用Redis

前言 最近有个想法想整理一个内容比较完整springboot项目初始化Demo。 SpringBoot使用Redis 缓存数据 一、 pom引入依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>&…

Logstash 安装与部署(无坑版)

下载 版本对照关系&#xff1a;ElasticSearch 7.9.2 和 Logstash 7.9.2 &#xff1b; 官方下载地址 选择ElasticSearch版本一致的Logstash版本 https://www.elastic.co/cn/downloads/logstash 下载链接&#xff1a;https://artifacts.elastic.co/downloads/logstash/logst…

FBX福币交易所A股三大指数小幅低开 稀土永磁板块回调

查查配分析11月5日电 周二,A股三大指数小幅低开。沪指开盘跌0.10%报3306.81点,深证成指开盘跌0.09%报10653.20点,创业板指开盘跌0.05%报2184.90点。 FBX福币凭借用户友好的界面和对透明度的承诺,迅速在加密货币市场中崭露头角,成为广大用户信赖的平台。 来源:同花顺iFinD 盘面…

基于python深度学习的交通标志图像识别设计与实现,卷积神经网络(CNN)作为主要架构

摘要 随着自动驾驶技术的发展&#xff0c;交通标志的识别与理解在智能交通系统中扮演着越来越重要的角色。本文设计并实现了一个基于深度学习的交通标志图像识别系统&#xff0c;通过对交通标志识别基准数据集的分析与处理&#xff0c;建立了一套完整的图像识别流程。使用Pyth…

js WebAPI黑马笔记(万字速通)

此笔记来自于黑马程序员&#xff0c;pink老师yyds 复习&#xff1a; splice() 方法用于添加或删除数组中的元素。 注意&#xff1a; 这种方法会改变原始数组。 删除数组&#xff1a; splice(起始位置&#xff0c; 删除的个数) 比如&#xff1a;1 let arr [red, green, b…

跟李沐学AI:BERT

什么是NLP中的迁移学习 使用预训练好的模型来抽取词、句子的特征&#xff1a;Word2Vec或者预训练好的语言模型。 使用预训练好的语言模型&#xff0c;一般不会再对语言模型进行微调&#xff0c;即不进行更新。 Word2Vec一般用于替代embedding层 但是Word2Vec往往忽略了时序…

【ArcGIS】绘制各省碳排放分布的中国地图

首先&#xff0c;准备好各省、自治区、直辖市及特别行政区&#xff08;包括九段线&#xff09;的shp文件&#xff1a; 通过百度网盘分享的文件&#xff1a;GS&#xff08;2022&#xff09;1873 链接&#xff1a;https://pan.baidu.com/s/1wq8-XM99LXG_P8q-jNgPJA 提取码&#…

Unity照片墙效果

Unity照片墙效果&#xff0c;如下效果展示 。 工程源码

开源模型应用落地-glm模型小试-glm-4-9b-chat-批量推理(二)

一、前言 GLM-4是智谱AI团队于2024年1月16日发布的基座大模型&#xff0c;旨在自动理解和规划用户的复杂指令&#xff0c;并能调用网页浏览器。其功能包括数据分析、图表创建、PPT生成等&#xff0c;支持128K的上下文窗口&#xff0c;使其在长文本处理和精度召回方面表现优异&a…

计算机网络:网络层 —— 路由信息协议 RIP

文章目录 路由选择协议动态路由协议路由信息协议 RIPRIP 的重要特点RIP的基本工作过程RIP的距离向量算法RIP存在的问题RIP版本和相关报文的封装 路由选择协议 因特网是全球最大的互联网&#xff0c;它所采取的路由选择协议具有以下三个主要特点&#xff1a; 自适应&#xff1a…

算法:图的相关算法

图的相关算法 1. 图的遍历算法1.1 深度优先搜索1.2 广度优先搜索 2. 最小生成树求解算法普里姆(Prim)算法克鲁斯卡尔(Kruskal)算法 3. 拓扑排序4. 最短路径算法 1. 图的遍历算法 图的遍历是指从某个顶点出发&#xff0c;沿着某条搜索路径对图中的所有顶点进行访问且只访问次的…

PowerCat反弹Shell

PowerCat介绍 PowerCat是一个powershell写的tcp/ip瑞士军刀&#xff0c;可以看成ncat的powershell的实现&#xff0c;然后里面也 加入了众多好用的功能&#xff0c;如文件上传&#xff0c;smb协议支持&#xff0c;中继模式&#xff0c;生成payload&#xff0c;端口扫描等等。 …