打卡day39

news2025/5/31 19:50:43

一、 图像数据的介绍

1.1 灰度图像

# 先继续之前的代码
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader , Dataset # DataLoader 是 PyTorch 中用于加载数据的工具
from torchvision import datasets, transforms # torchvision 是一个用于计算机视觉的库，datasets 和 transforms 是其中的模块
import matplotlib.pyplot as plt
# 设置随机种子，确保结果可复现
torch.manual_seed(42)

# 1. 数据预处理，该写法非常类似于管道pipeline
# transforms 模块提供了一系列常用的图像预处理操作

# 先归一化，再标准化
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量并归一化到[0,1]
    transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差，这个值很出名，所以直接使用
])
import matplotlib.pyplot as plt

# 2. 加载MNIST数据集，如果没有会自动下载
train_dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    transform=transform
)

# 先继续之前的代码
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader , Dataset # DataLoader 是 PyTorch 中用于加载数据的工具
from torchvision import datasets, transforms # torchvision 是一个用于计算机视觉的库，datasets 和 transforms 是其中的模块
import matplotlib.pyplot as plt
# 设置随机种子，确保结果可复现
torch.manual_seed(42)

# 1. 数据预处理，该写法非常类似于管道pipeline
# transforms 模块提供了一系列常用的图像预处理操作

# 先归一化，再标准化
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量并归一化到[0,1]
    transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差，这个值很出名，所以直接使用
])
import matplotlib.pyplot as plt

# 2. 加载MNIST数据集，如果没有会自动下载
train_dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    transform=transform
)

图像数据与结构化数据有什么差异点？
结构化数据（如表格）的形状通常是 (样本数, 特征数)，例如 (1000, 5) 表示 1000 个样本，每个样本有 5 个特征。图像数据的形状更复杂，需要保留空间信息（高度、宽度、通道），因此不能直接用一维向量表示。其中颜色信息往往是最开始输入数据的通道的含义，因为每个颜色可以用红绿蓝三原色表示，因此一般输入数据的通道数是 3。

维度索引含义数值说明
0通道数（Channels）1 表示这是一张灰度图（仅有一个颜色通道，如黑白照片）。
如果是彩色图（如RGB），通道数为 3。
1高度（Height）28 表示图像的垂直像素数为28像素。
2宽度（Width）28 表示图像的水平像素数为28像素。

MNIST 数据集是手写数字的 灰度图像，每个像素点的取值范围为 0-255（黑白程度），因此 通道数为 1。图像尺寸统一为 28×28 像素。

# 打印下图片的形状
image.shape

# 输出
torch.Size([1, 28, 28])

1.2 彩色图像

在 PyTorch 中，图像数据的形状通常遵循 (通道数, 高度, 宽度) 的格式（即 Channel First 格式），这与常见的 (高度, 宽度, 通道数)（Channel Last，如 NumPy 数组）不同。—注意顺序关系，

注意点：

  1. 如果用matplotlib库来画图，需要转换下顺序，我们后续介绍
  2. 模型输入通常需要 批次维度（Batch Size），形状变为 (批次大小, 通道数, 高度, 宽度)。例如，批量输入 10 张 MNIST 图像时，形状为 (10, 1, 28, 28)。
# 打印一张彩色图像，用cifar-10数据集
import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 设置随机种子确保结果可复现
torch.manual_seed(42)
# 定义数据预处理步骤
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量并归一化到[0,1]
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 标准化处理
])

# 加载CIFAR-10训练集
trainset = torchvision.datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

# 创建数据加载器
trainloader = torch.utils.data.DataLoader(
    trainset,
    batch_size=4,
    shuffle=True
)

# CIFAR-10的10个类别
classes = ('plane', 'car', 'bird', 'cat', 'deer', 
           'dog', 'frog', 'horse', 'ship', 'truck')

# 随机选择一张图片
sample_idx = torch.randint(0, len(trainset), size=(1,)).item()
image, label = trainset[sample_idx]

# 打印图片形状
print(f"图像形状: {image.shape}")  # 输出: torch.Size([3, 32, 32])
print(f"图像类别: {classes[label]}")

# 定义图像显示函数（适用于CIFAR-10彩色图像）
def imshow(img):
    img = img / 2 + 0.5  # 反标准化处理，将图像范围从[-1,1]转回[0,1]
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))  # 调整维度顺序：(通道,高,宽) → (高,宽,通道)
    plt.axis('off')  # 关闭坐标轴显示
    plt.show()

# 显示图像
imshow(image)

注意，因为这里设计到图像的显示，所以就需要调整维度顺序：(通道,高,宽) → (高,宽,通道)
介绍下超参数的优化 优化器优化手写数字问题 引出cnn如何计算显存一次性可以读取多少张随机种子

二、 图像相关的神经网络的定义

考虑课程内容的推进，今日的内容只提定义，不涉及训练和测试过程

2.1 黑白图像模型的定义

# 先归一化，再标准化
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量并归一化到[0,1]
    transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差，这个值很出名，所以直接使用
])
import matplotlib.pyplot as plt

# 2. 加载MNIST数据集，如果没有会自动下载
train_dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    transform=transform
)


# 定义两层MLP神经网络
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.flatten = nn.Flatten()  # 将28x28的图像展平为784维向量
        self.layer1 = nn.Linear(784, 128)  # 第一层：784个输入，128个神经元
        self.relu = nn.ReLU()  # 激活函数
        self.layer2 = nn.Linear(128, 10)  # 第二层：128个输入，10个输出（对应10个数字类别）
        
    def forward(self, x):
        x = self.flatten(x)  # 展平图像
        x = self.layer1(x)   # 第一层线性变换
        x = self.relu(x)     # 应用ReLU激活函数
        x = self.layer2(x)   # 第二层线性变换，输出logits
        return x

# 初始化模型
model = MLP()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)  # 将模型移至GPU（如果可用）

from torchsummary import summary  # 导入torchsummary库
print("\n模型结构信息：")
summary(model, input_size=(1, 28, 28))  # 输入尺寸为MNIST图像尺寸

我们关注和之前结构化MLP的差异

  1. 输入需要展平操作

MLP 的输入层要求输入是一维向量，但 MNIST 图像是二维结构（28×28 像素），形状为 [1, 28, 28]（通道 × 高 × 宽）。nn.Flatten()展平操作 将二维图像 “拉成” 一维向量（784=28×28 个元素），使其符合全连接层的输入格式。

其中不定义这个flatten方法，直接在前向传播的过程中用 x = x.view(-1, 28 * 28) 将图像展平为一维向量也可以实现

  1. 输入数据的尺寸包含了通道数input_size=(1, 28, 28)

  2. 参数的计算

  • 第一层 layer1（全连接层）

权重参数：输入维度 × 输出维度 = 784 × 128 = 100,352

偏置参数：输出维度 = 128

合计：100,352 + 128 = 100,480

  • 第二层 layer2（全连接层）

权重参数：输入维度 × 输出维度 = 128 × 10 = 1,280

偏置参数：输出维度 = 10
合计：1,280 + 10 = 1,290

  • 总参数：100,480（layer1） + 1,290（layer2） = 101,770

2.2 彩色图像模型的定义

class MLP(nn.Module):
    def __init__(self, input_size=3072, hidden_size=128, num_classes=10):
        super(MLP, self).__init__()
        # 展平层：将3×32×32的彩色图像转为一维向量
        # 输入尺寸计算：3通道 × 32高 × 32宽 = 3072
        self.flatten = nn.Flatten()
        
        # 全连接层
        self.fc1 = nn.Linear(input_size, hidden_size)  # 第一层
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)  # 输出层
        
    def forward(self, x):
        x = self.flatten(x)  # 展平：[batch, 3, 32, 32] → [batch, 3072]
        x = self.fc1(x)      # 线性变换：[batch, 3072] → [batch, 128]
        x = self.relu(x)     # 激活函数
        x = self.fc2(x)      # 输出层：[batch, 128] → [batch, 10]
        return x

# 初始化模型
model = MLP()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)  # 将模型移至GPU（如果可用）

from torchsummary import summary  # 导入torchsummary库
print("\n模型结构信息：")
summary(model, input_size=(3, 32, 32))  # CIFAR-10 彩色图像（3×32×32）
  • 第一层 layer1（全连接层）

权重参数：输入维度 × 输出维度 = 3072 × 128 = 393,216

偏置参数：输出维度 = 128

合计：393,216 + 128 = 393,344

  • 第二层 layer2（全连接层）

权重参数：输入维度 × 输出维度 = 128 × 10 = 1,280

偏置参数：输出维度 = 10

合计：1,280 + 10 = 1,290

  • 总参数：393,344（layer1） + 1,290（layer2） = 394,634

2.3 模型定义与batchsize的关系

实际定义中，输入图像还存在batchsize这一维度

在 PyTorch 中，模型定义和输入尺寸的指定不依赖于 batch_size，无论设置多大的 batch_size，模型结构和输入尺寸的写法都是不变的。

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten() # nn.Flatten()会将每个样本的图像展平为 784 维向量，但保留 batch 维度。
        self.layer1 = nn.Linear(784, 128)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.flatten(x)  # 输入：[batch_size, 1, 28, 28] → [batch_size, 784]
        x = self.layer1(x)   # [batch_size, 784] → [batch_size, 128]
        x = self.relu(x)
        x = self.layer2(x)   # [batch_size, 128] → [batch_size, 10]
        return x

PyTorch 模型会自动处理 batch 维度（即第一维），无论 batch_size 是多少，模型的计算逻辑都不变。batch_size 是在数据加载阶段定义的，与模型结构无关。

summary(model, input_size=(1, 28, 28))中的input_size不包含 batch 维度，只需指定样本的形状（通道 × 高 × 宽）。

总结：batch_size与模型定义的关系**

组件是否涉及batch_size示例代码
模型定义❌ 完全无关class MLP(nn.Module) 中无需提及batch_size
torchsummary❌ 只需要样本形状（不含batch维度）summary(model, input_size=(1, 28, 28))
DataLoader✅ 在此设置batch_sizeDataLoader(dataset, batch_size=64)
训练循环✅ 数据自动以batch形式输入模型for data, target in train_loader: ...

三、显存占用的主要组成部分

昨天说到了在面对数据集过大的情况下，由于无法一次性将数据全部加入到显存中，所以采取了分批次加载这种方式。即一次只加载一部分数据，保证在显存的范围内。

那么显存设置多少合适呢？如果设置的太小，那么每个batchsize的训练不足以发挥显卡的能力，浪费计算资源；如果设置的太大，会出现OOT（out of memory）

显存一般被以下内容占用：

  1. 模型参数与梯度：模型的权重（Parameters）和对应的梯度（Gradients）会占用显存，尤其是深度神经网络（如 Transformer、ResNet 等），一个 1 亿参数的模型（如 BERT-base），单精度（float32）参数占用约 400MB（1e8×4Byte），加上梯度则翻倍至 800MB（每个权重参数都有其对应的梯度）。

  2. 部分优化器（如 Adam）会为每个参数存储动量（Momentum）和平方梯度（Square Gradient），进一步增加显存占用（通常为参数大小的 2-3 倍）

  3. 其他开销。

oom处理方案

下面以手写数据集为例

from torch.utils.data import DataLoader

# 定义训练集的数据加载器，并指定batch_size
train_loader = DataLoader(
    dataset=train_dataset,  # 加载的数据集
    batch_size=64,          # 每次加载64张图像
    shuffle=True            # 训练时打乱数据顺序
)

# 定义测试集的数据加载器（通常batch_size更大，减少测试时间）
test_loader = DataLoader(
    dataset=test_dataset,
    batch_size=1000,
    shuffle=False
)

手写数据集（MNIST）和当前 MLP 模型，显存占用的计算可以简化为以下几个部分。

3.1 模型参数与梯度（FP32 精度）

参数总量：101,770 个参数

  • 1字节（Byte）= 8位（bit），是计算机存储的最小寻址单位。
  • 位（bit）是二进制数的最小单位（0或1），例如0b1010表示4位二进制数。
  • 1KB=1024字节；1MB=1024KB=1,048,576字节

常见数据类型的字节占用

数据类型位数（bit）字节（Byte）数值范围（近似）
float32（单精度浮点数）324±1.7×10^38
float64（双精度浮点数）648±1.8×10^308
uint8（无符号8位整数）810~255
  • MNIST数据集的原始图像像素值为0-255的整数（uint8类型，占1字节），表示灰度值（0=黑，255=白）。
  • 但PyTorch的transforms.ToTensor()会将其归一化到[0, 1]范围，并转换为 float32类型（浮点型更适合神经网络计算）。

计算示例：单张MNIST图像的显存占用

  1. 原始像素值（uint8，未转换时）

    • 尺寸：28×28像素
    • 单像素占用：1字节（uint8）
    • 总占用：28×28×1 = 784字节 ≈ 0.766 KB

  2. 转换为float32张量后

    • 尺寸：1×28×28（通道×高×宽）
    • 单像素占用：4字节（float32）
    • 总占用：1×28×28×4 = 3136字节 ≈ 3.06 KB

单精度（float32）参数占用：101,770 × 4 Byte ≈ 403 KB

梯度是损失函数对模型参数的导数（∂Loss/∂Weight），用于指示参数更新的方向和幅度。梯度是损失函数对模型参数的导数（∂Loss/∂Weight），用于指示参数更新的方向和幅度。因此在默认情况下，梯度的数据类型和数目与参数相同。

梯度占用（反向传播时）：与参数相同，合计约 806 KB

3.2 优化器状态

SGD
  • SGD优化器不存储额外动量，因此无额外显存占用。
  • SGD 随机梯度下降，最基础的优化器，直接沿梯度反方向更新参数。
  • 参数更新公式：w = w - learning_rate * gradient
Adam
  • Adam优化器：自适应学习率优化器，结合了动量（Momentum）和梯度平方的指数移动平均。
  • 每个参数存储动量（m）和平方梯度（v），占用约 101,770 × 8 Byte ≈ 806 KB
  • 动量（m）：每个参数对应一个动量值，数据类型与参数相同（float32），占用 403 KB。
  • 梯度平方（v）：每个参数对应一个梯度平方值，数据类型与参数相同（float32），占用 403 KB。

3.3 数据批量（batch_size）的显存占用

  • 单张图像尺寸：1×28×28（通道×高×宽），归一化转换为张量后为float32类型
    • 单张图像显存占用：1×28×28×4 Byte = 3,136 Byte ≈ 3 KB
  • 批量数据占用：batch_size × 单张图像占用
    • 例如：batch_size=64 时，数据占用为 64×3 KB ≈ 192 KB
    • batch_size=1024 时，数据占用为 1024×3 KB ≈ 3 MB

3.4. 前向/反向传播中间变量

  • 对于两层MLP，中间变量（如layer1的输出）占用较小：
    • batch_size×128维向量：batch_size×128×4 Byte = batch_size×512 Byte
    • 例如batch_size=1024时，中间变量约 512 KB
      以SGD为例，此时其他参数占用固定，batchsize会影响显存占用
batch_size数据占用中间变量总显存占用（近似）
64192 KB32 KB~1 MB
256768 KB128 KB~1.7 MB
10243 MB512 KB~4.5 MB
409612 MB2 MB~15 MB
在 PyTorch 中，在使用DataLoader加载数据时，如果不指定batch_size参数，默认值是1

，即每次迭代返回一个样本。这与一次性使用全部数据进行训练是完全不同的概念。如果想要一次性使用全部数据进行训练，需要手动将batch_size设置为数据集的大小，但对于大型数据集，这样做通常会导致内存不足，因为一次性将所有数据加载到内存中可能会超出硬件的内存限制。

大规模数据时，通常从16开始测试，然后逐渐增加，确保代码运行正常且不报错，直到出现 内存不足（OOM）报错 或训练效果下降，此时选择略小于该值的 batch_size。

训练时候搭配 nvidia-smi 监控显存占用，合适的 batch_size = 硬件显存允许的最大值 × 0.8（预留安全空间），并通过训练效果验证调整。
补充说明： batchsize对于训练的影响

在深度学习中，使用较大的 batch_size（批量大小）相比单样本训练（batch_size=1）有以下核心优势

  • 并行计算能力最大化，减小训练时间；且大幅减少更新次数
  • 梯度方向更准确，单样本训练的梯度仅基于单个数据点，可能包含大量噪声（尤其是数据分布不均或存在异常值时）。大 batch_size 的梯度是多个样本的平均值，能抵消单个样本的随机性，梯度方向更接近真实分布的 “全局最优方向”。会让训练过程更稳定，波动更小
场景计算过程参数更新方式
batch_size=1计算1个样本的损失 $ L_1 $ → 反向传播得到梯度 $ g_1 $直接用 $ g_1 $ 更新参数
batch_size=12计算12个样本的损失 $ L_1, L_2, …, L_{12} $ → 分别求梯度 $ g_1, g_2, …, g_{12} $ → 计算平均梯度 $ \bar{g} = \frac{g_1 + g_2 + … + g_{12}}{12} $用平均梯度 $ \bar{g} $ 更新参数

@浙大疏锦行

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

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

相关文章

基于Web的分布式图集管理系统架构设计与实践

基于Web的分布式图集管理系统架构设计与实践

引言：为什么需要分布式图集管理？ 在现代Web图形应用中，纹理图集（Texture Atlas）技术是优化渲染性能的关键手段。传统的图集制作流程通常需要美术人员使用专业工具（如TexturePacker）离线制作&am…
阅读更多...
mysql执行sql语句报错事务锁住

mysql执行sql语句报错事务锁住

报错情况 1205 - Lock wait timeout exceeded; try restarting transaction先找出长时间运行的事务 SELECT * FROM information_schema.INNODB_TRX ORDER BY trx_started ASC;终止长时间运行的事务 KILL [PROCESS_ID];
阅读更多...
Java消息队列应用：Kafka、RabbitMQ选择与优化

Java消息队列应用：Kafka、RabbitMQ选择与优化

Java消息队列应用：Kafka、RabbitMQ选择与优化 在Java应用领域，消息队列是实现异步通信、应用解耦、流量削峰等重要功能的关键组件。Kafka和RabbitMQ作为两种主流的消息队列技术，各有特点和适用场景。本文将深入探讨Kafka和RabbitMQ在Java中的…
阅读更多...
零基础设计模式——结构型模式 - 组合模式

零基础设计模式——结构型模式 - 组合模式

第三部分：结构型模式 - 组合模式 (Composite Pattern) 在学习了桥接模式如何分离抽象和实现以应对多维度变化后，我们来探讨组合模式。组合模式允许你将对象组合成树形结构来表现“整体-部分”的层次结构。组合模式使得用户对单个对象和组合对象的使用具…
阅读更多...
腾讯云国际站可靠性测试

腾讯云国际站可靠性测试

在数字化转型加速的今天，企业对于云服务的依赖已从“可选”变为“必需”。无论是跨境电商的实时交易，还是跨国企业的数据协同，云服务的可靠性直接决定了业务连续性。作为中国领先的云服务提供商，腾讯云国际站（Tencent …
阅读更多...
自定义异常小练习

自定义异常小练习

在开始之前,让我们高喊我们的口号： ​​​​​​​ 键盘敲烂,年薪百万！ 目录 键盘敲烂,年薪百万！ 异常综合练习： 自定义异常 异常综合练习： 自定义异常： 定义异常类写继承关系空参构造带参构造 自定…
阅读更多...
SpringBoot整合MinIO实现文件上传

SpringBoot整合MinIO实现文件上传

使用Spring Boot与JSP和MinIO（一个开源对象存储系统，兼容Amazon S3）进行集成，您可以创建一个Web应用来上传、存储和管理文件。以下是如何将Spring Boot、JSP和MinIO集成的基本步骤： 这个是minio正确启动界面 这个是min…
阅读更多...
基于面向对象设计的C++日期推算引擎：精准高效的时间运算实现与运算重载工程化实践

基于面向对象设计的C++日期推算引擎：精准高效的时间运算实现与运算重载工程化实践

前引： 在软件开发中，时间与日期的处理是基础但极具挑战性的任务。传统的手工日期运算逻辑往往面临闰年规则、月份天数动态变化、时区转换等复杂场景的容错难题，且代码冗余度高、可维护性差。本文将深入探讨如何利用C的面向对象特性与成员函数…
阅读更多...
如何把 Microsoft Word 中所有的汉字字体替换为宋体？

如何把 Microsoft Word 中所有的汉字字体替换为宋体？

Ctrl H ，然后，点击更多，勾选使用通配符，查找内容中填入 [一-龥]{1,}， 这是 Word 通配符匹配汉字的经典写法（匹配 Unicode 范围内的 CJK 汉字）。 然后， “替换为”留空，点…
阅读更多...
02. [Python+Golang+PHP]三数之和，多种语言实现最优解demo

02. [Python+Golang+PHP]三数之和，多种语言实现最优解demo

一、问题描述：三数之和 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i ! j、i ! k 且 j ! k ，同时还满足 nums[i] nums[j] nums[k] 0 。请你返回所有和为 0 且不重复的三元组。 注意：答案中…
阅读更多...
倚光科技在二元衍射面加工技术上的革新：引领光学元件制造新方向​

倚光科技在二元衍射面加工技术上的革新：引领光学元件制造新方向​

倚光科技二元衍射面加工技术（呈现出细腻的光碟反射纹路） 在光学元件制造领域，二元衍射面的加工技术一直是行业发展的关键驱动力之一。其精准的光相位调制能力，在诸多前沿光学应用中扮演着不可或缺的角色。然而，长期以来…
阅读更多...
驱动开发(2)|鲁班猫rk3568简单GPIO波形操控

驱动开发(2)|鲁班猫rk3568简单GPIO波形操控

上篇文章写了如何下载内核源码、编译源码的详细步骤，以及一个简单的官方demo编译，今天分享一下如何根据板子的引脚写自己控制GPIO进行高低电平反转。 想要控制GPIO之前要学会看自己的引脚分布图，我用的是鲁班猫RK3568，引脚分布图如…
阅读更多...
《软件工程》第 3 章 -需求工程概论

《软件工程》第 3 章 -需求工程概论

在软件工程的开发流程中，需求工程是奠定项目成功基础的关键环节。它专注于获取、分析、定义和管理软件需求，确保开发出的软件能真正满足用户需求。接下来，我们将按照目录内容，结合 Java 代码和实际案例，深入讲解需求工…
阅读更多...
VMware-MySQL主从

VMware-MySQL主从

MySQL主从 服务器信息 服务器类型角色主机地址主机名称虚拟机master192.168.40.128test-1虚拟机slave192.168.40.129test-2 Master 配置（192.168.40.128） 删除自动生成的配置 /var/lib/mysql/auto.cnf [roottest-1 ~]# rm -rf /var/lib/mysql/auto.…
阅读更多...
2023-ICLR-ReAct 首次结合Thought和Action提升大模型解决问题的能力

2023-ICLR-ReAct 首次结合Thought和Action提升大模型解决问题的能力

关于普林斯顿大学和Google Research, Brain Team合作的一篇文章, 在语言模型中协同Reasoning推理和Action行动。 论文地址：https://arxiv.org/abs/2210.03629 代码：https://github.com/ysymyth/ReAct.git 其他复现 langchain ：https://pytho…
阅读更多...
Rust 开发的一些GUI库

Rust 开发的一些GUI库

最近考虑用Rust干点什么，于是搜集了下资料——根据2025年最新调研结果和社区实践，Rust GUI库生态已形成多个成熟度不同的解决方案。以下是当前主流的GUI库分类及特点分析，结合跨平台支持、开发体验和实际应用场景进行综合评估： 一…
阅读更多...
【第四十六周】文献阅读：从 RAG 到记忆：大型语言模型的非参数持续学习

【第四十六周】文献阅读：从 RAG 到记忆：大型语言模型的非参数持续学习

目录 摘要Abstract从 RAG 到记忆：大型语言模型的非参数持续学习研究背景方法论1. 离线索引（Offline Indexing）2. 在线检索（Online Retrieval）具体细节 创新性实验结果局限性总结 摘要 本论文旨在解决当前检索增强生成…
阅读更多...
从智能提效到产品赋能的架构实践

从智能提效到产品赋能的架构实践

摘要 本文深入探讨了企业级系统从智能化提效阶段向产品赋能阶段演进的架构实践路径。通过分析传统架构的局限性，提出了以用户价值为导向的现代化架构设计理念，并结合实际案例展示了如何构建可扩展、高可用、智能化的产品架构体系。 1. 引言 在数字化转型的浪潮中，企业技术…
阅读更多...
关于OT IIOT系统远程访问的零信任安全

关于OT IIOT系统远程访问的零信任安全

什么是OT & IIOT？—— 工业领域的“操作基石”与“智能升级” 在工业数字化转型的浪潮中，OT（运营技术）与IIoT（工业物联网）是两个核心概念。前者是工业生产的“神经中枢”，后者是驱动智能升…
阅读更多...
【Doris基础】Apache Doris vs 传统数据仓库：架构与性能的全面对比

【Doris基础】Apache Doris vs 传统数据仓库：架构与性能的全面对比

目录 1 引言 1.1 传统数据仓库的发展 1.2 现代分析型数据库的崛起 2 核心架构对比 2.1 传统数据仓库的架构 2.2 Doris的架构设计 3 关键技术差异 3.1 存储引擎对比 3.2 查询执行对比 3.3 数据摄入方式对比 4 性能与扩展性对比 4.1 性能基准对比 4.2 扩展性对比 5…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023