深度学习 - Transformer 组成详解

news2024/10/7 14:23:46

整体结构

在这里插入图片描述

1. 嵌入层（Embedding Layer）

在这里插入图片描述
生活中的例子：字典查找

想象你在读一本书，你不认识某个单词，于是你查阅字典。字典为每个单词提供了一个解释，帮助你理解这个单词的意思。嵌入层就像这个字典，它将每个单词（或输入序列中的每个标记）映射到一个高维向量（解释），这个向量包含了单词的各种语义信息。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import math

class EmbeddingLayer(nn.Module):
    def __init__(self, vocab_size, d_model, max_seq_length=512):
        super(EmbeddingLayer, self).__init__()
        # vocab_size: 词汇表的大小，即输入序列中可能的不同标记的总数。
        # d_model: 每个嵌入向量的维度，即词嵌入向量的长度。
        # max_seq_length: 序列的最大长度，用于位置嵌入。
        self.embedding = nn.Embedding(vocab_size, d_model)  # 词嵌入层
        self.pos_embedding = nn.Embedding(max_seq_length, d_model)  # 位置嵌入层
        self.d_model = d_model

        # 初始化位置编码
        pe = torch.zeros(max_len, d_model)
        # 生成词位置列表
        position = torch.arange(0, max_len).unsqueeze(1)
        # 根据公式计算词位置参数
        div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
        # 生成词位置矩阵
        my_matmulres = position * div_term
        # 给位置编码矩阵奇数列，赋值sin曲线特征
        pe[:, 0::2] = torch.sin(my_matmulres)
        # 给位置编码矩阵偶数列，赋值cos曲线特征
        pe[:, 1::2] = torch.cos(my_matmulres)

        # 形状变化 [max_seq_length,d_model]-->[1,max_seq_length,d_model]
        pe = pe.unsqueeze(0)

        # 把pe位置编码矩阵 注册成模型的持久缓冲区buffer; 模型保存再加载时，可以根模型参数一样，一同被加载
        # 什么是buffer: 对模型效果有帮助的，但是却不是模型结构中超参数或者参数，不参与模型训练
        self.register_buffer('pe', pe)

    def forward(self, x):
        seq_length = x.size(1)  # 序列长度
        pos = torch.arange(0, seq_length, device=x.device).unsqueeze(0)  # 生成位置索引
        return self.embedding(x) * math.sqrt(self.d_model) + self.pe[:,:x.size()[-1], :]  # 词嵌入和位置嵌入相加

2. 多头自注意力机制（Multi-Head Self-Attention）

在这里插入图片描述
生活中的例子：小组讨论

想象你在一个小组讨论中，每个人（每个位置上的单词）都提出自己的观点（Query），并听取其他人的意见（Key和Value）。每个人对所有其他人的观点进行加权平均，以形成自己的新观点。多头注意力机制类似于多个小组同时进行讨论，每个小组从不同的角度（头）讨论问题，然后将所有讨论结果合并在一起。

class MultiHeadSelfAttention(nn.Module):
    def __init__(self, d_model, nhead):
        super(MultiHeadSelfAttention, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        self.nhead = nhead
        self.d_model = d_model

        # 定义线性变换层
        self.q_linear = nn.Linear(d_model, d_model)
        self.k_linear = nn.Linear(d_model, d_model)
        self.v_linear = nn.Linear(d_model, d_model)
        self.out_linear = nn.Linear(d_model, d_model)

        self.scale = (d_model // nhead) ** 0.5  # 缩放因子

    def forward(self, x):
        batch_size = x.size(0)  # 获取批大小
        # 线性变换并分成多头
        q = self.q_linear(x).view(batch_size, -1, self.nhead, self.d_model // self.nhead).transpose(1, 2)
        k = self.k_linear(x).view(batch_size, -1, self.nhead, self.d_model // self.nhead).transpose(1, 2)
        v = self.v_linear(x).view(batch_size, -1, self.nhead, self.d_model // self.nhead).transpose(1, 2)

        # 计算注意力得分
        scores = torch.matmul(q, k.transpose(-2, -1)) / self.scale
        attn = torch.nn.functional.softmax(scores, dim=-1)  # 计算注意力权重
        context = torch.matmul(attn, v).transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)  # 加权求和
        out = self.out_linear(context)  # 最后一层线性变换
        return out

3. 前馈神经网络（Feed-Forward Network）

在这里插入图片描述
生活中的例子：信息过滤和处理

想象你在整理会议纪要，需要对会议地录音进行归纳、总结和补充。前馈神经网络类似于这个过程，它对输入的信息进行进一步处理和转换，以提取重要特征。

class FeedForwardNetwork(nn.Module):
    def __init__(self, d_model, dim_feedforward, dropout=0.1):
        super(FeedForwardNetwork, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在前馈神经网络中使用的dropout比率，用于正则化。
        self.linear1 = nn.Linear(d_model, dim_feedforward)  # 第一个线性层
        self.dropout = nn.Dropout(dropout)  # dropout层
        self.linear2 = nn.Linear(dim_feedforward, d_model)  # 第二个线性层

    def forward(self, x):
        return self.linear2(self.dropout(torch.nn.functional.relu(self.linear1(x))))  # 激活函数ReLU和dropout

4. 层归一化（Layer Normalization）

在这里插入图片描述
生活中的例子：团队合作中的标准化

想象你在一个团队中工作，每个人都有不同的工作习惯和标准。为了更好地合作，团队决定采用统一的工作标准（如文档格式、命名规范等）。层归一化类似于这种标准化过程，它将输入归一化，使得每个特征的均值为0，标准差为1，以稳定和加速训练。

class LayerNorm(nn.Module):
    def __init__(self, d_model, eps=1e-6):
        super(LayerNorm, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # eps: 用于数值稳定的小值，防止除以零。
        self.gamma = nn.Parameter(torch.ones(d_model))  # 缩放参数
        self.beta = nn.Parameter(torch.zeros(d_model))  # 偏移参数
        self.eps = eps  # epsilon，用于数值稳定

    def forward(self, x):
        mean = x.mean(dim=-1, keepdim=True)  # 计算均值
        std = x.std(dim=-1, keepdim=True)  # 计算标准差
        return self.gamma * (x - mean) / (std + self.eps) + self.beta  # 归一化

5. 残差连接（Residual Connection）

在这里插入图片描述
生活中的例子：备忘录

想象你在会议上记了很多笔记。为了确保不会遗漏任何重要信息，你在总结时会参照这些笔记。残差连接类似于这个过程，它将每层的输入直接加到输出上，确保信息不会在层与层之间丢失。

class ResidualConnection(nn.Module):
    def __init__(self, d_model, dropout=0.1):
        super(ResidualConnection, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # dropout: 在残差连接中使用的dropout比率，用于正则化。
        self.norm = LayerNorm(d_model)  # 层归一化
        self.dropout = nn.Dropout(dropout)  # dropout层

    def forward(self, x, sublayer):
        return x + self.dropout(sublayer(self.norm(x)))  # 残差连接

6. 编码器层（Encoder Layer）

在这里插入图片描述
生活中的例子：多轮面试

想象你在参加多轮面试，每轮面试都有不同的考官，考察不同的方面（如专业知识、沟通能力等）。每轮面试都帮助你更全面地展示自己。编码器层类似于这种多轮面试的过程，每层处理输入序列的不同方面，逐层提取和增强特征。

class EncoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward, dropout=0.1):
        super(EncoderLayer, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.self_attn = MultiHeadSelfAttention(d_model, nhead)  # 多头自注意力机制
        self.feed_forward = FeedForwardNetwork(d_model, dim_feedforward, dropout)  # 前馈神经网络
        self.sublayers = nn.ModuleList([ResidualConnection(d_model, dropout) for _ in range(2)])  # 两个子层（注意力和前馈网络）

    def forward(self, src):
        src = self.sublayers[0](src, lambda x: self.self_attn(x))  # 应用自注意力机制
        src = self.sublayers[1](src, self.feed_forward)  # 应用前馈神经网络
        return src

7. 解码器层（Decoder Layer）

在这里插入图片描述
生活中的例子：逐步解谜

想象你在玩一个解谜游戏，每解决一个谜题（每层解码器），你都会得到新的线索，逐步解开整个谜题。解码器层类似于这种逐步解谜的过程，每层结合当前解码的结果和编码器的输出，逐步生成目标序列。

class DecoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward, dropout=0.1):
        super(DecoderLayer, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.self_attn = MultiHeadSelfAttention(d_model, nhead)  # 多头自注意力机制
        self.cross_attn = MultiHeadSelfAttention(d_model, nhead)  # 编码器-解码器注意力
        self.feed_forward = FeedForwardNetwork(d_model, dim_feedforward, dropout)  # 前馈神经网络
        self.sublayers = nn.ModuleList([ResidualConnection(d_model, dropout) for _ in range(3)])  # 三个子层（自注意力、交叉注意力、前馈网络）

    def forward(self, tgt, memory):
        tgt = self.sublayers[0](tgt, lambda x: self.self_attn(x))  # 应用自注意力机制
        tgt = self.sublayers[1](tgt, lambda x: self.cross_attn(x, memory))  # 应用编码器-解码器注意力
        tgt = self.sublayers[2](tgt, self.feed_forward)  # 应用前馈神经网络
        return tgt

8. 编码器（Encoder）

在这里插入图片描述

class Encoder(nn.Module):
    def __init__(self, num_layers, d_model, nhead, dim_feedforward, dropout=0.1):
        super(Encoder, self).__init__()
        # num_layers: 编码器层的数量，即堆叠的编码器层数。
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.layers = nn.ModuleList([EncoderLayer(d_model, nhead, dim_feedforward, dropout) for _ in range(num_layers)])  # 堆叠多个编码器层

    def forward(self, src):
        for layer in self.layers:
            src = layer(src)  # 依次通过每个编码器层
        return src

9. 解码器（Decoder）

class Decoder(nn.Module):
    def __init__(self, num_layers, d_model, nhead, dim_feedforward, dropout=0.1):
        super(Decoder, self).__init__()
        # num_layers: 解码器层的数量，即堆叠的解码器层数。
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.layers = nn.ModuleList([DecoderLayer(d_model, nhead, dim_feedforward, dropout) for _ in range(num_layers)])  # 堆叠多个解码器层

    def forward(self, tgt, memory):
        for layer in self.layers:
            tgt = layer(tgt, memory)  # 依次通过每个解码器层
        return tgt

10. Transformer模型

class TransformerModel(nn.Module):
    def __init__(self, vocab_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout=0.1):
        super(TransformerModel, self).__init__()
        # vocab_size: 词汇表的大小，即输入序列中可能的不同标记的总数。
        # d_model: 每个嵌入向量的维度，即词嵌入向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # num_encoder_layers: 编码器层的数量，即堆叠的编码器层数。
        # num_decoder_layers: 解码器层的数量，即堆叠的解码器层数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.embedding = EmbeddingLayer(vocab_size, d_model)  # 嵌入层
        self.encoder = Encoder(num_encoder_layers, d_model, nhead, dim_feedforward, dropout)  # 编码器
        self.decoder = Decoder(num_decoder_layers, d_model, nhead, dim_feedforward, dropout)  # 解码器
        self.fc = nn.Linear(d_model, vocab_size)  # 最后一层线性变换，将输出维度映射到

词汇表大小

    def forward(self, src, tgt):
        src = self.embedding(src)  # 嵌入输入序列
        tgt = self.embedding(tgt)  # 嵌入目标序列
        memory = self.encoder(src)  # 编码器处理输入序列
        output = self.decoder(tgt, memory)  # 解码器处理目标序列
        output = self.fc(output)  # 映射到词汇表大小
        return output

训练示例

# 参数
# vocab_size: 词汇表的大小，即输入序列中可能的不同标记的总数。
# d_model: 每个嵌入向量的维度，即词嵌入向量的长度。
# nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
# num_encoder_layers: 编码器层的数量，即堆叠的编码器层数。
# num_decoder_layers: 解码器层的数量，即堆叠的解码器层数。
# dim_feedforward: 前馈神经网络的隐藏层维度。
# dropout: 在各层中使用的dropout比率，用于正则化。
# batch_size: 每个训练批次中的样本数量。
# seq_length: 输入序列的长度。
# num_epochs: 训练的轮数，即遍历整个训练集的次数。
vocab_size = 1000
d_model = 512
nhead = 8
num_encoder_layers = 6
num_decoder_layers = 6
dim_feedforward = 2048
dropout = 0.1
batch_size = 32
seq_length = 10
num_epochs = 10

# 数据集
src = torch.randint(0, vocab_size, (batch_size, seq_length))
tgt = torch.randint(0, vocab_size, (batch_size, seq_length))

dataset = TensorDataset(src, tgt)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 模型实例
model = TransformerModel(vocab_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout)

# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练
for epoch in range(num_epochs):
    for src_batch, tgt_batch in dataloader:
        tgt_input = tgt_batch[:, :-1]  # 目标输入
        tgt_output = tgt_batch[:, 1:]  # 目标输出

        optimizer.zero_grad()
        output = model(src_batch, tgt_input)  # 前向传播
        output = output.permute(1, 2, 0)  # 调整形状以匹配损失函数
        loss = criterion(output, tgt_output)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

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

print("训练完成")

代码说明

  1. EmbeddingLayer：将输入序列和位置嵌入映射到高维空间。
  2. MultiHeadSelfAttention：实现多头自注意力机制，包括查询、键和值的线性变换和注意力计算。
  3. FeedForwardNetwork：前馈神经网络，用于进一步处理特征。
  4. LayerNorm：层归一化，用于稳定训练过程。
  5. ResidualConnection：残差连接，帮助训练更深的网络。
  6. EncoderLayer：将多头自注意力机制和前馈神经网络组合在一起，形成编码器层。
  7. DecoderLayer：包括多头自注意力机制、编码器-解码器注意力和前馈神经网络，形成解码器层。
  8. Encoder：由多个编码器层堆叠而成。
  9. Decoder：由多个解码器层堆叠而成。
  10. TransformerModel：将编码器和解码器组合在一起，形成完整的Transformer模型。

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

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

相关文章

代码随想录-二叉搜索树（1）

代码随想录-二叉搜索树（1）

目录 二叉搜索树的定义 700. 二叉搜索树中的搜索 题目描述： 输入输出示例： 思路和想法： 98. 验证二叉搜索树 题目描述： 输入输出示例： 思路和想法： 530. 二叉搜索树的最小绝对差 题目描述&#x…
阅读更多...
IOS Swift 从入门到精通：ios 连接数据库 安装 Firebase 和 Firestore

IOS Swift 从入门到精通：ios 连接数据库 安装 Firebase 和 Firestore

创建 Firebase 项目 导航到Firebase 控制台并创建一个新项目。为项目指定任意名称。 在这里插入图片描述 下一步，启用 Google Analytics，因为我们稍后会用到它来发送推送通知。 在这里插入图片描述 在下一个屏幕上，选择您的 Google Analytics 帐户（如果已创建）。如果没…
阅读更多...
java第三十课 —— 面向对象练习题

java第三十课 —— 面向对象练习题

面向对象编程练习题 第一题 定义一个 Person 类 {name, age, job}，初始化 Person 对象数组，有 3 个 person 对象，并按照 age 从大到小进行排序，提示，使用冒泡排序。 package com.hspedu.homework;import java.util.…
阅读更多...
使用slenium对不同元素进行定位实战篇~

使用slenium对不同元素进行定位实战篇~

单选框Radio定位： 单选框只能点击一个，并且点击之后并不会被取消，而多选框，能够点击多个，并且点击之后可以取消 import org.junit.Test; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; imp…
阅读更多...
基于python和opencv实现边缘检测程序

基于python和opencv实现边缘检测程序

引言 图像处理是计算机视觉中的一个重要领域，它在许多应用中扮演着关键角色，如自动驾驶、医疗图像分析和人脸识别等。边缘检测是图像处理中的基本任务之一，它用于识别图像中的显著边界。本文将通过一个基于 Python 和 OpenCV 的示例程序&…
阅读更多...
intellij idea安装R包ggplot2报错问题求解

intellij idea安装R包ggplot2报错问题求解

1、intellij idea安装R包ggplot2问题 在我上次解决图形显示问题后，发现安装ggplot2包时出现了问题，这在之前高版本中并没有出现问题， install.packages(ggplot2) ERROR: lazy loading failed for package lifecycle * removing C:/Users/V…
阅读更多...
Android 10.0 关于定制自适应AdaptiveIconDrawable类型的动态时钟图标的功能实现系列二(拖动到文件夹部分功能实现)

Android 10.0 关于定制自适应AdaptiveIconDrawable类型的动态时钟图标的功能实现系列二(拖动到文件夹部分功能实现)

1.前言 在10.0的系统rom定制化开发中，在关于定制动态时钟图标中，原系统是不支持动态时钟图标的功能，所以就需要从新 定制动态时钟图标关于自适应AdaptiveIconDrawable类型的样式，就是可以支持当改变系统图标样式变化时，动态时钟 图标的背景图形也跟着改变，本篇实现在拖…
阅读更多...
HBuilder X 小白日记02-布局和网页背景颜色

HBuilder X 小白日记02-布局和网页背景颜色

html&#xff1a; 例子1&#xff1a; 整个&#xff1a; css案例&#xff1a; 1.首先右键&#xff0c;创建css文件 2.在html文件的头部分&#xff0c;引用css&#xff0c;快捷方式&#xff1a;linkTab键 <link rel"stylesheet" href" "> 3.先在css…
阅读更多...
操作系统精选题（二）（综合模拟题一）

操作系统精选题（二）（综合模拟题一）

&#x1f308; 个人主页&#xff1a;十二月的猫-CSDN博客 &#x1f525; 系列专栏&#xff1a; &#x1f3c0;操作系统 &#x1f4aa;&#x1f3fb; 十二月的寒冬阻挡不了春天的脚步&#xff0c;十二点的黑夜遮蔽不住黎明的曙光 目录 前言 简答题 一、进程由计算和IO操作组…
阅读更多...
论文阅读之旋转目标检测ARC:《Adaptive Rotated Convolution for Rotated Object Detection》

论文阅读之旋转目标检测ARC:《Adaptive Rotated Convolution for Rotated Object Detection》

论文link&#xff1a;link code&#xff1a;code ARC是一个改进的backbone&#xff0c;相比于ResNet&#xff0c;最后的几层有一些改变。 Introduction ARC自适应地旋转以调整每个输入的条件参数&#xff0c;其中旋转角度由路由函数以数据相关的方式预测。此外&#xff0c;还采…
阅读更多...
【Unity】Timeline的倒播和修改速度（无需协程）

【Unity】Timeline的倒播和修改速度（无需协程）

unity timeline倒播 一、核心&#xff1a; 通过playableDirector.playableGraph.GetRootPlayable(i).SetSpeed(speed)接口&#xff0c;设置PlayableDirector的速度。 二、playableGraph报空 若playableDirector不勾选Play On Awake&#xff0c;则默认没有PlayableGraph&…
阅读更多...
Redis基础教程（三）：redis命令

Redis基础教程（三）：redis命令

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; &#x1f49d;&#x1f49…
阅读更多...
oj E : 投资项目的方案

oj E : 投资项目的方案

Description 有n种基础的投资项目&#xff0c;每一种的单位收益率为profitn&#xff0c;存在m种投资组合&#xff0c;限制每一种的投资总额不能超过invest_summ 每种投资组合中项目所需的单位投入是不同的&#xff0c;为costmn 求&#xff1a;使得收益率之和最高的每种项目投…
阅读更多...
Meven

Meven

目录 1.简介2.Maven项目目录结构2.1 约定目录结构的意义2.2 约定大于配置 3. POM.XML介绍3.2 依赖引用3.3 属性管理 4 Maven生命周期4.1 经常遇到的生命周期4.1 全部生命周期 5.依赖范围&#xff08;Scope&#xff09;6. 依赖传递6.1 依赖冲突6.2 解决依赖冲突6.2.1 最近依赖者…
阅读更多...
1、线性回归模型

1、线性回归模型

1、主要解决问题类型 1.1 预测分析（Prediction） 线性回归可以用来预测一个变量（通常称为因变量或响应变量）的值，基于一个或多个输入变量（自变量或预测变量）。例如，根据房屋的面积、位置等因素预测房价。 1.2 异常检测（Outlier Detection） 线性回归可以帮助识别数…
阅读更多...
vscode-创建vue3项目-修改暗黑主题-常见错误-element插件标签-用法涉及问题

vscode-创建vue3项目-修改暗黑主题-常见错误-element插件标签-用法涉及问题

文章目录 1.vscode创建运行编译vue3项目2.添加项目资源3.添加element-plus元素4.修改为暗黑主题4.1.在main.js主文件中引入暗黑样式4.2.添加自定义样式文件4.3.html页面html标签添加样式 5.常见错误5.1.未使用变量5.2.关闭typescript检查5.3.调试器支持5.4.允许未到达代码和未定…
阅读更多...
量产工具一一显示系统（一）

量产工具一一显示系统（一）

目录 前言 一、项目介绍和应用 1.简单易用 2.软件可配置、易扩展 3.纯 C 语言编程 4.类似界面应用 二、项目总体框架 三、显示系统 1.显示系统数据结构抽象 &#xff08;1&#xff09;common.h &#xff08;2&#xff09;disp_manager.h 2.Framebuffer编程 &#x…
阅读更多...
Conformal Prediction

Conformal Prediction

1 A Gentle Introduction to Conformal Prediction and Distribution-Free Uncertainty Quantification 2 Language Models with Conformal Factuality Guarantees
阅读更多...
《数据结构与算法基础 by王卓老师》学习笔记——类C语言有关操作补充

《数据结构与算法基础 by王卓老师》学习笔记——类C语言有关操作补充

1.元素类型说明 2.数组定义 3.C语言的内存动态分配 4..C中的参数传递 5.传值方式 6.传地址方式 例子
阅读更多...
grpc学习golang版（ 一、基本概念与安装 ）

grpc学习golang版（ 一、基本概念与安装 ）

系列文章目录 第一章 grpc基本概念与安装 第二章 grpc入门示例 第三章 proto文件数据类型 第四章 多服务示例 第五章 多proto文件示例 第六章 服务器流式传输 第七章 客户端流式传输 第八章 双向流示例 文章目录 一、基本介绍1.1 什么是rpc1.2 什么是grpc1.3 grpc的作用1.4 grp…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023