【深度学习实验】前馈神经网络(final):自定义鸢尾花分类前馈神经网络模型并进行训练及评价

news2024/10/7 12:27:19

目录

一、实验介绍

 二、实验环境

1. 配置虚拟环境

2. 库版本介绍

三、实验内容

0. 导入必要的工具包

1. 构建数据集(IrisDataset)

2. 构建模型(FeedForward)

a. __init__(初始化)

b. forward(前向传播)

3.整合训练、评估、预测过程(Runner)

4. 模型评价(Accuracy)

5. __main__

6. 代码整合


一、实验介绍

        鸢尾花分类(通过输入鸢尾花的特征信息,预测鸢尾花的种类)是一个常见的机器学习问题。本次实验旨在使用PyTorch构建一个简单的鸢尾花分类前馈神经网络模型,并进行训练和评价,以了解PyTorch的基本使用方法和模型训练过程。

 二、实验环境

    本系列实验使用了PyTorch深度学习框架,相关操作如下:

1. 配置虚拟环境

conda create -n DL python=3.7 
conda activate DL
pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html
conda install matplotlib
 conda install scikit-learn

2. 库版本介绍

软件包本实验版本目前最新版
matplotlib3.5.33.8.0
numpy1.21.61.26.0
python3.7.16
scikit-learn0.22.11.3.0
torch1.8.1+cu1022.0.1
torchaudio0.8.12.0.2
torchvision0.9.1+cu1020.15.2

三、实验内容

ChatGPT:

        前馈神经网络(Feedforward Neural Network)是一种常见的人工神经网络模型,也被称为多层感知器(Multilayer Perceptron,MLP)。它是一种基于前向传播的模型,主要用于解决分类和回归问题。

        前馈神经网络由多个层组成,包括输入层、隐藏层和输出层。它的名称"前馈"源于信号在网络中只能向前流动,即从输入层经过隐藏层最终到达输出层,没有反馈连接。

以下是前馈神经网络的一般工作原理:

  1. 输入层:接收原始数据或特征向量作为网络的输入,每个输入被表示为网络的一个神经元。每个神经元将输入加权并通过激活函数进行转换,产生一个输出信号。

  2. 隐藏层:前馈神经网络可以包含一个或多个隐藏层,每个隐藏层由多个神经元组成。隐藏层的神经元接收来自上一层的输入,并将加权和经过激活函数转换后的信号传递给下一层。

  3. 输出层:最后一个隐藏层的输出被传递到输出层,输出层通常由一个或多个神经元组成。输出层的神经元根据要解决的问题类型(分类或回归)使用适当的激活函数(如Sigmoid、Softmax等)将最终结果输出。

  4. 前向传播:信号从输入层通过隐藏层传递到输出层的过程称为前向传播。在前向传播过程中,每个神经元将前一层的输出乘以相应的权重,并将结果传递给下一层。这样的计算通过网络中的每一层逐层进行,直到产生最终的输出。

  5. 损失函数和训练:前馈神经网络的训练过程通常涉及定义一个损失函数,用于衡量模型预测输出与真实标签之间的差异。常见的损失函数包括均方误差(Mean Squared Error)和交叉熵(Cross-Entropy)。通过使用反向传播算法(Backpropagation)和优化算法(如梯度下降),网络根据损失函数的梯度进行参数调整,以最小化损失函数的值。

        前馈神经网络的优点包括能够处理复杂的非线性关系,适用于各种问题类型,并且能够通过训练来自动学习特征表示。然而,它也存在一些挑战,如容易过拟合、对大规模数据和高维数据的处理较困难等。为了应对这些挑战,一些改进的网络结构和训练技术被提出,如卷积神经网络(Convolutional Neural Networks)和循环神经网络(Recurrent Neural Networks)等。

本系列为实验内容,对理论知识不进行详细阐释

(咳咳,其实是没时间整理,待有缘之时,回来填坑)

977468b5ae9843c6a88005e792817cb1.png

0. 导入必要的工具包

import torch
from torch import nn
import torch.nn.functional as F
# 绘画时使用的工具包
import matplotlib.pyplot as plt
# 导入鸢尾花数据集
from sklearn.datasets import load_iris
# 构建自己的数据集,继承自Dataset类
from torch.utils.data import Dataset, DataLoader

1. 构建数据集(IrisDataset)

  • 本实验使用了鸢尾花数据集,该数据集包含150个样本,每个样本有4个特征和1个标签。
  • load_iris函数加载数据集,并进行数据归一化处理;
  • 自定义的IrisDataset类用于数据加载,构建训练集、验证集和测试集。

【深度学习实验】前馈神经网络(七):批量加载数据(直接加载数据→定义类封装数据)_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133181882?spm=1001.2014.3001.5501

2. 构建模型(FeedForward)

       本实验构建了一个简单的两层前馈神经网络。这个前馈神经网络和前文实现的MLP类最大的区别在于,我们实现类中使用了自己写的激活函数,该激活函数不能通过反向传播更新参数,但深度学习框架已经帮我们完成了这个功能。(其实通过简单的改动,我们的激活函数也可以反传梯度)

【深度学习实验】前馈神经网络(三):自定义多层感知机(激活函数logistic、线性层算Linear)_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133097102?spm=1001.2014.3001.5501

class FeedForward(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(FeedForward,self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.act = nn.Sigmoid()
    
    def forward(self, inputs):
        outputs = self.fc1(inputs)
        outputs = self.act(outputs)
        outputs = self.fc2(outputs)
        return outputs

a. __init__(初始化)

  • 三个参数:
    • input_size(输入大小)
    • hidden_size(隐藏层大小)
    • output_size(输出大小)
  • 调用父类nn.Module的初始化方法super(FeedForward, self).init(),确保正确地初始化该类作为一个nn.Module。
  • 两个线性层self.fc1和self.fc2:
    • self.fc1的输入大小为input_size,输出大小为hidden_size;
    • self.fc2的输入大小为hidden_size,输出大小为output_size。
  • 一个激活函数self.act,这里使用的是nn.Sigmoid(),即Sigmoid激活函数。

b. forward(前向传播)

  • 接受一个输入张量inputs。在前向传播过程中,
    • 输入经过self.fc1线性层,
    • 然后通过self.act激活函数进行非线性变换,
    • 再经过self.fc2线性层得到最终的输出张量outputs

3.整合训练、评估、预测过程(Runner)

        Runner类封装了模型训练和评价的过程。

  • 初始化函数接收模型、优化器、损失函数和评价指标等参数,并定义了一些成员变量用于记录训练过程中的损失和评价指标变化。
  • train函数进行模型的训练
  • evaluate函数进行模型的评价
  • predict函数进行模型的预测
  • save_model和load_model函数用于保存和加载模型的参数

【深度学习实验】前馈神经网络(九):整合训练、评估、预测过程(Runner)_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133219448?spm=1001.2014.3001.5501

4. 模型评价(Accuracy)

【深度学习实验】前馈神经网络(八):模型评价(自定义支持分批进行评价的Accuracy类)_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133186305?spm=1001.2014.3001.5501

5. __main__

if __name__ == '__main__':
    batch_size = 16

    # 分别构建训练集、验证集和测试集
    train_dataset = IrisDataset(mode='train')
    dev_dataset = IrisDataset(mode='dev')
    test_dataset = IrisDataset(mode='test')

    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    dev_loader = DataLoader(dev_dataset, batch_size=batch_size)
    test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)

    input_size = 4
    output_size = 3
    hidden_size = 6
    # 定义模型
    model = FeedForward(input_size, hidden_size, output_size)
    # 定义损失函数
    loss_fn = F.cross_entropy
    # 定义优化器
    optimizer = torch.optim.SGD(model.parameters(), lr=0.2)
    # 定义评价方法
    metric = Accuracy(is_logist=True)
    # 实例化辅助runner类
    runner = Runner(model, optimizer, loss_fn, metric)
    # 模型训练
    runner.train(train_loader, dev_loader, num_epochs=50, log_steps=10, eval_steps=5)
    # 训练结束后,网络的参数会自动保存为.pth结尾的文件,且与训练文件在同一目录下
    model_path = 'model_25.pth'
    # 首先读入经过训练后的网络的参数
    runner.load_model(model_path)
    x, label = next(iter(test_loader))
    print(runner.predict(x.float()))
    print(label)

  • batch_size = 16 设置批大小,用于数据加载器;

  • 构建训练集、验证集和测试集的数据集对象;

  • 创建数据加载器;

  • 设置模型的输入大小、输出大小和隐藏层大小:

    • input_size = 4 输入大小为4,对应于鸢尾花数据集的特征数量。
    • output_size = 3 输出大小为3,对应于鸢尾花数据集的类别数量。
    • hidden_size = 6 隐藏层大小为6,作为前馈神经网络模型的隐藏层的单元数。
  • 定义模型、损失函数、优化器和评价指标:

    • 前馈神经网络模型:使用FeedForward类,设置输入、隐藏层和输出大小。
    • 损失函数:使用交叉熵损失函数F.cross_entropy
    • 优化器:使用随机梯度下降法(SGD),学习率为0.2。
    • 评价指标:使用Accuracy类。
  • 创建辅助的Runner类对象用于训练和评价模型。

  • 进行模型训练:

    • 设置训练数据加载器为train_loader,验证数据加载器为dev_loader,训练的轮次为50,打印日志的频率为每10步打印一次日志,评价的频率为每5个epoch进行一次评价。
  • 训练结束后,通过调用runner.load_model(model_path)方法加载模型的参数

  • 构造一个测试样本 x 和标签 label,调用 runner.predict(x.float()) 方法对样本进行预测,并输出预测结果。随后输出真实标签 label

6. 代码整合

# 导入必要的工具包
import torch
from torch import nn
import torch.nn.functional as F
# 绘画时使用的工具包
import matplotlib.pyplot as plt
# 导入鸢尾花数据集
from sklearn.datasets import load_iris
# 构建自己的数据集,继承自Dataset类
from torch.utils.data import Dataset, DataLoader


# 此函数用于加载鸢尾花数据集
def load_data(shuffle=True):
    x = torch.tensor(load_iris().data)
    y = torch.tensor(load_iris().target)

    # 数据归一化
    x_min = torch.min(x, dim=0).values
    x_max = torch.max(x, dim=0).values
    x = (x - x_min) / (x_max - x_min)

    if shuffle:
        idx = torch.randperm(x.shape[0])
        x = x[idx]
        y = y[idx]
    return x, y


class IrisDataset(Dataset):
    def __init__(self, mode='train', num_train=120, num_dev=15):
        super(IrisDataset, self).__init__()
        x, y = load_data(shuffle=True)
        if mode == 'train':
            self.x, self.y = x[:num_train], y[:num_train]
        elif mode == 'dev':
            self.x, self.y = x[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
        else:
            self.x, self.y = x[num_train + num_dev:], y[num_train + num_dev:]

    def __getitem__(self, idx):
        return self.x[idx], self.y[idx]

    def __len__(self):
        return len(self.x)


class FeedForward(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(FeedForward, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.act = nn.Sigmoid()

    def forward(self, inputs):
        outputs = self.fc1(inputs)
        outputs = self.act(outputs)
        outputs = self.fc2(outputs)
        return outputs


# 支持分批进行模型评价的 Accuracy 类
class Accuracy:
    def __init__(self, is_logist=True):
        # 正确样本个数
        self.num_correct = 0
        # 样本总数
        self.num_count = 0
        self.is_logist = is_logist

    def update(self, outputs, labels):
        # 判断是否为二分类任务
        if outputs.shape[1] == 1:
            outputs = outputs.squeeze(-1)
            # 判断是否是logit形式的预测值
            if self.is_logist:
                preds = (outputs >= 0).long()
            else:
                preds = (outputs >= 0.5).long()
        else:
            # 多分类任务时,计算最大元素索引作为类别
            preds = torch.argmax(outputs, dim=1).long()

        # 获取本批数据中预测正确的样本个数
        labels = labels.squeeze(-1)
        batch_correct = (preds == labels).float().sum()
        batch_count = len(labels)
        # 更新
        self.num_correct += batch_correct
        self.num_count += batch_count

    def accumulate(self):
        # 使用累计的数据,计算总的评价指标
        if self.num_count == 0:
            return 0
        return self.num_correct / self.num_count

    def reset(self):
        self.num_correct = 0
        self.num_count = 0


class Runner(object):
    def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
        self.model = model
        self.optimizer = optimizer
        self.loss_fn = loss_fn
        # 用于计算评价指标
        self.metric = metric

        # 记录训练过程中的评价指标变化
        self.dev_scores = []
        # 记录训练过程中的损失变化
        self.train_epoch_losses = []
        self.dev_losses = []
        # 记录全局最优评价指标
        self.best_score = 0

    # 模型训练阶段
    def train(self, train_loader, dev_loader=None, **kwargs):
        # 将模型设置为训练模式,此时模型的参数会被更新
        self.model.train()
        num_epochs = kwargs.get('num_epochs', 0)
        log_steps = kwargs.get('log_steps', 100)
        save_path = kwargs.get('save_path', 'best_mode.pth')
        eval_steps = kwargs.get('eval_steps', 0)
        # 运行的step数,不等于epoch数
        global_step = 0

        if eval_steps:
            if dev_loader is None:
                raise RuntimeError('Error: dev_loader can not be None!')
            if self.metric is None:
                raise RuntimeError('Error: Metric can not be None')

        # 遍历训练的轮数
        for epoch in range(num_epochs):
            total_loss = 0
            # 遍历数据集
            for step, data in enumerate(train_loader):
                x, y = data
                logits = self.model(x.float())
                loss = self.loss_fn(logits, y.long())
                total_loss += loss
                if log_steps and global_step % log_steps == 0:
                    print(f'loss:{loss.item():.5f}')

                loss.backward()
                self.optimizer.step()
                self.optimizer.zero_grad()
            # 每隔一定轮次进行一次验证,由eval_steps参数控制,可以采用不同的验证判断条件
            if (epoch + 1) % eval_steps == 0:

                dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
                print(f'[Evalute] dev score:{dev_score:.5f}, dev loss:{dev_loss:.5f}')

                if dev_score > self.best_score:
                    self.save_model(f'model_{epoch + 1}.pth')

                    print(
                        f'[Evaluate]best accuracy performance has been updated: {self.best_score:.5f}-->{dev_score:.5f}')
                    self.best_score = dev_score

                # 验证过程结束后,请记住将模型调回训练模式
                self.model.train()

            global_step += 1
            # 保存当前轮次训练损失的累计值
            train_loss = (total_loss / len(train_loader)).item()
            self.train_epoch_losses.append((global_step, train_loss))

        print('[Train] Train done')

    # 模型评价阶段
    def evaluate(self, dev_loader, **kwargs):
        assert self.metric is not None
        # 将模型设置为验证模式,此模式下,模型的参数不会更新
        self.model.eval()
        global_step = kwargs.get('global_step', -1)
        total_loss = 0
        self.metric.reset()

        for batch_id, data in enumerate(dev_loader):
            x, y = data
            logits = self.model(x.float())
            loss = self.loss_fn(logits, y.long()).item()
            total_loss += loss
            self.metric.update(logits, y)

        dev_loss = (total_loss / len(dev_loader))
        self.dev_losses.append((global_step, dev_loss))
        dev_score = self.metric.accumulate()
        self.dev_scores.append(dev_score)
        return dev_score, dev_loss

    # 模型预测阶段,
    def predict(self, x, **kwargs):
        self.model.eval()
        logits = self.model(x)
        return logits

    # 保存模型的参数
    def save_model(self, save_path):
        torch.save(self.model.state_dict(), save_path)

    # 读取模型的参数
    def load_model(self, model_path):
        self.model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))


if __name__ == '__main__':
    batch_size = 16

    # 分别构建训练集、验证集和测试集
    train_dataset = IrisDataset(mode='train')
    dev_dataset = IrisDataset(mode='dev')
    test_dataset = IrisDataset(mode='test')

    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    dev_loader = DataLoader(dev_dataset, batch_size=batch_size)
    test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)

    input_size = 4
    output_size = 3
    hidden_size = 6
    # 定义模型
    model = FeedForward(input_size, hidden_size, output_size)
    # 定义损失函数
    loss_fn = F.cross_entropy
    # 定义优化器
    optimizer = torch.optim.SGD(model.parameters(), lr=0.2)
    # 定义评价方法
    metric = Accuracy(is_logist=True)
    # 实例化辅助runner类
    runner = Runner(model, optimizer, loss_fn, metric)
    # 模型训练
    runner.train(train_loader, dev_loader, num_epochs=50, log_steps=10, eval_steps=5)
    # 训练结束后,网络的参数会自动保存为.pth结尾的文件,且与训练文件在同一目录下
    model_path = 'model_25.pth'
    # 首先读入经过训练后的网络的参数
    runner.load_model(model_path)
    x, label = next(iter(test_loader))
    print(runner.predict(x.float()))
    print(label)

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

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

相关文章

Json文件反序列化读取

Json文件 [{"name":"清华大学","location":"北京","grade":"1"},{"name":"北京大学","location":"北京","grade":"2"} ] 安装包 代码 Program.c…

Redis应用(8)——Redis的项目应用:结合SpringBoot如何在Redis里面存对象 RedisUtil工具类的封装 遇到的问题

前言 Redis作为一款优秀的开源、高效的内存数据库,在各种项目中都能见到其身影,熟练使用Redis是程序员必备的技能之一。本系列博客结合应用场景,阐述Redis从安装到使用的,从入门到进阶的相关内容。 本篇博客介绍在Spring项目中&…

免费AI人工智能,人工智能写文章软件

在当今信息爆炸的时代,内容创作已经成为了无处不在的需求。从博客、新闻报道到广告宣传,人们对于高质量的文本内容的需求愈发迫切。然而,面对繁忙的生活节奏和不断增长的写作任务,许多创作者感到焦头烂额。 从博客作者到广告写手&…

系统集成|第十六章(笔记)

目录 第十六章 信息(文档)和配置管理16.1 文档管理16.2 配置管理 上篇:第十五章、采购管理 下篇:第十七章、变更管理 第十六章 信息(文档)和配置管理 16.1 文档管理 信息系统项目相关信息(文档…

记录一次错误---想让U-net网络输入大小不一致的图片

最近在看Deeplab系列的论文,文中提到了语义分割领域的一个难题是:将图片输入网络之前需要resize成统一大小,但是resize的话会造成细节信息的损失,所以想要网络处理任意大小的图片输入。我之前训练的U-net网络都是resize成224*224大…

基于若依ruoyi-nbcio支持flowable流程角色,同时修改流转用户为username,流程启动做大调整(三)

更多ruoyi-nbcio功能请看演示系统 gitee源代码地址 前后端代码: ruoyi-nbcio: nbcio-boot的若依版本,基于ruoyi-flowable-plus和flowable6.7.2,目前处于移植功能阶段,目标是打造一个最好的若依平台上flowable流程管理系统开源版本&#xff0c…

【项目】Http服务器

【项目】Http服务器 项目简介 背景: http协议被广泛使用,从移动端,pc端浏览器,http协议无疑是打开互联网应用窗口的重要协议,http在网络应用层中的地位不可撼动,是能准确区分前后台的重要协议。 描述&a…

MD5 绕过第一式:弱比较绕过

文章目录 参考环境MD5韧性脆弱性md5() 隐式类型转换字符串连接数学运算布尔判断相等运算符 科学计数法科学计数法前缀 0E 与 0e PHP8 与 PHP 其他版本下字符串转化为数值的具体规则PHP8数值字符串优化 其他版本更为详细的讲解 字符串与字符串的弱比较字符串与数值的弱比较0e215…

git查看自己所在的分支

很多时候可能大家不太想切换其他工具,又不知道自己是否在自己需要操作的分支 可以直接终端执行 git branch此时 他就会在终端将所有的本地分支输出出来 并特殊标注自己所在的分支 这样我们就可以进一步去做自己想要做的操作了 当然 随着各种编辑器的发展 这个命令…

视频剪辑软件哪个好? 2023年最新功能解析

如今聊到视频的话题,大家可能都注意到近年来火爆的抖音短视频。从图片到动画,从动画到视频。时代在发展,技术在更新。到了近几年小视频也火了,其实不乏缺有视频剪辑软件的功劳。现在不少朋友在业余时间都喜欢剪辑视频来丰富自己的…

支撑电动汽车规模化,特来电智能化升级群充产品

9月26日,中国领先的充电网生态运营商特来电重磅发布智能群充4.0产品,标志着特来电群充产品体系进一步升级,充电行业迎来更高质量、更高性能的设备与系统,充电网基础设施将更好地支撑大规模电动汽车的发展。 群充技术路线引领充电…

音频处理基础的一些笔记碎片

感谢 B 站上关于 EQ 扫盲视频分享 🔊声音变好听-让均衡器改变你的音色|均衡器怎么调?(adobe audition 2020基础教程) 简要内容 a. 人耳能够听到的频率 20HZ-20000HZ; b. 人耳普遍认为低于 80HZ 是噪声; c. …

华为智能企业上网行为管理安全解决方案(1)

华为智能企业上网行为管理安全解决方案(1) 课程地址方案背景需求分析企业上网行为概述企业上网行为安全风险分析企业上网行为管理需求分析 方案设计组网架构设备选型设备简介行为管理要点分析方案功能概述 课程地址 本方案相关课程资源已在华为O3社区发…

MQTT协议知识梳理,看完你就懂了!

一.MQTT简介 MQTT是基于TCP/IP协议栈构建的异步通信消息协议,是一种轻量级的发布/订阅信息传输协议。MQTT在时间和空间上,将消息发送者与接受者分离,可以在不可靠的网络环境中进行扩展。 适用于设备硬件存储空间有限或网络带宽有限的场景。物…

SpringBoot 员工管理---通用模板 ---苍穹外卖day2

感谢点击 希望你有所收获! 目录 1.新增员工 需求分析:根据页面原型进行业务分析 接口设计 数据库设计 代码开发 功能测试 如何在接口文档中统一添加JWT令牌 ​ 获取当前登录员工的ID 2.员工分页查询 需求分析 代码开发 如何将日期格式化 ​3.启用禁用员工 1.新…

软件设计模式——工厂模式

摘要 本博文主要介绍软件设计模式中工厂模式,其中工厂设计模式的扩展为简单工厂(Simple Factory)、工厂方法(Factory Method)、抽象工厂(Abstract Factory)三种。 一、简单工厂(Simple Factory) 主要分析设计模式 - 简单工厂(Simple Factory),它把实例…

day07_方法

今日内容 零、 复习昨日 一、作业讲解 二、方法[重点] 零、 复习昨日 一、作业讲解 package com.qf.homework;import java.util.Scanner;/*** desc*/ public class Homework {public static void main(String[] args) {/*** --------------------* 边写边测试* 以结果倒推* …

HTML详细基础(二)文件路径

目录 一.相对路径 二.绝对路径 三.超链接标签 四.锚点链接 首先,扩展一些HTML执行的原理: htmL(hypertext markup Language) 是一种规范(或者说是一种标准),它通过标记符(tag)来标记要显示…

D课堂 | 什么是DNS?DNS是怎么运作的?

想象一下,你在一个陌生的城市,想去一家餐厅品尝美食。你知道这家餐厅的名字,但却不知道它的具体位置。 这时,你可能会打开手机地图,输入餐厅的名字,然后地图会告诉你如何到达那里。 在互联网世界里&#xf…

向量数据库库Milvus Cloud2.3 的QA问题

1. Milvus 从 2.2.x 升级至 2.3.x 的最大变化是什么? 如果用一句话来总结,那就是使用的场景更加丰富了。具体可以从两个方面来体现,即部署环境和用户的使用感。 例如,从部署环境来看,Milvus 原来只支持 X86 架构的 CPU,版本升级后,不仅可以支持 GPU,还能够支持 ARM 架构…