深度学习 Pytorch 基础网络手动搭建与快速实现

为了方便后续练习的展开，我们尝试自己创建一个数据生成器，用于自主生成一些符合某些条件、具备某些特性的数据集。

导入相关的包

# 随机模块
import random

# 绘图模块
import matplotlib as mpl
import matplotlib.pyplot as plt

# 导入numpy
import numpy as np

# 导入pytorch
import torch
from torch import nn, optim
import torch.nn.functional as F
from torch.utils.data import Dataset, TensorDataset, DataLoader

以上均为此前用到的包，其它新的包将在使用时再进行导入及介绍。


46 回归类数据集创建方法

46.1 手动生成数据

回归类模型的数据，特征和标签都是连续性数值。

正常情况，应该是对于连续型数值标签的预测，我们采用回归类模型，此处因为先生成数据后进行建模，因此我们称可用于回归模型训练的数据为回归类模型数据，分类模型数据亦然。


数据生成

生成两个特征、存在偏差，自变量和因变量存在线性关系的数据集

num_inputs = 2		# 两个特征
num_examples = 100	# 总共一千条数据

然后通过线性方程，确定自变量和因变量的真实关系

torch.manual_seed(420)		# 设置随机数种子

# 线性方程系数
w_true = torch.tensor([2, -1]).reshape(2, 1)
b_true = torch.tensor(1.)

# 特征和标签取值
features = torch.randn(num_examples, num_inputs)
labels_true = torch.mm(features, w_true) + b_true
labels = labels_true + torch.randn(size = labels_true.shape) * 0.01

此处设置所有的数据都是浮点型。

注意，此时labels_true和features满足严格意义上的线性方程关系
y = 2 x 1 − x 2 + 1 y = 2x_1-x_2+1 y=2x1​−x2​+1
但我们实际使用的标签labels，则是在labels_true的基础上增添了一个扰动项，torch.randn(size = labels_true.shape) * 0.01，这其实也符合我们一般获取数据的情况：真实客观世界或许存在某个规律，但我们搜集到的数据往往会因为各种原因存在一定的误差，无法完全描述真实世界的客观规律，这其实也是模型误差的来源之一（另一个误差来源是模型本身捕获规律的能力）。这其中， y = 2 x 1 − x 2 + 1 y=2x_1-x_2+1 y=2x1​−x2​+1相当于我们从上帝视角创建的数据真实服从的规律，而扰动项，则相当于人为创造的获取数据时的误差。

这种按照某种规律生成数据、又 人为添加扰动项 的创建数据的方法，也是数学领域创建数据的一般方法。


数据探索

features[: 10]
# output :
tensor([[-0.0070,  0.5044],
        [ 0.6704, -0.3829],
        [ 0.0302,  0.3826],
        [-0.5131,  0.7104],
        [ 1.8092,  0.4352],
        [ 2.6453,  0.2654],
        [ 0.9235, -0.4376],
        [ 2.0182,  1.3498],
        [-0.2523, -0.0355],
        [-0.0646, -0.5918]])

labels[: 10]
# output :
tensor([[ 0.4735],
        [ 2.7285],
        [ 0.6764],
        [-0.7537],
        [ 4.1722],
        [ 6.0236],
        [ 3.2936],
        [ 3.6706],
        [ 0.5282],
        [ 1.4557]])

plt.subplot(121)
plt.scatter(features[:, 0], labels)		# 第一个特征和标签的关系
plt.subplot(122)
plt.scatter(features[:, 1], labels)		# 第二个特征和标签的关系

在这里插入图片描述

不难看出，两个特征和标签都存在一定的线性关系，并且跟特征的系数绝对值有很大关系。当然，若要增加线性模型的建模难度，可以增加扰动项的数值比例，从而削弱线性关系。

# 设置随机数种子
torch.manual_seed(420)

# 修改因变量
labels1 = labels_true + torch.randn(size = labels_true) * 2

# 可视化展示

# 扰动较小的情况
plt.subplot(221)
plt.scatter(features[:, 0], labels)             # 第一个特征和标签的关系
plt.subplot(222)
plt.plot(features[:, 1], labels, 'ro')          # 第二个特征和标签的关系

# 扰动较大的情况
plt.subplot(223)
plt.scatter(features[:, 0], labels1)             # 第一个特征和标签的关系
plt.subplot(224)
plt.plot(features[:, 1], labels1, 'yo')          # 第二个特征和标签的关系

在这里插入图片描述

当然，我们也能生成非线性关系的数据集，此处我们创建满足 y = x 2 + 1 y=x^2+1 y=x2+1规律的数据集。

# 设置随机数种子
torch.manual_seed(420)   

num_inputs = 2               # 两个特征
num_examples = 1000          # 总共一千条数据

# 线性方程系数
w_true = torch.tensor(2.)
b_true = torch.tensor(1.)

# 特征和标签取值
features = torch.randn(num_examples, num_inputs)
labels_true = torch.pow(features, 2) * w_true + b_true
labels = labels_true + torch.randn(size = labels_true.shape) * 0.1

# 可视化展示
plt.scatter(features, labels)

在这里插入图片描述


46.2 创建生成回归类数据的函数

为了方便后续使用，我们将上述过程封装在一个函数内

定义创建函数

def tensorGenReg(num_examples = 1000, w = [2, -1, 1], bias = True, deg = 1):
    """回归类数据集创建函数。
    :param num_examples: 创建数据集的数据量
    :param w: 包括截距的（如果存在）特征系数向量
    :param bias：是否需要截距
    :param delta：扰动项取值
    :param deg：方程次数
    :return: 生成的特征张量和标签张量
    """
    if bias == True:
        num_inputs = len(w) - 1
        features_true = torch.randn(num_examples, num_inputs)
        w_true = torch.tensor(w[:-1]).reshape(-1, 1).float()
        b_true = torch.tensor(w[-1]).float()
        if num_inputs == 1:
            # 若输入特征只有1个，则不能使用矩阵乘法
            labels_true = torch.pow(features_true, deg) * w_true + n_true
        else:
            labels_true = torch.mm(torch.pow(features_true, deg), w_true) + b_true
        # 在特征张量的最后添加一列全是1的列
        features = torch.cat((features_true,  torch.ones(len(features_true), 1)), 1)
    else:
        num_inputs = len(w)
        features = torch.randn(num_examples, num_inputs)
        w_true = torch.tensor(w).reshape(-1, 1).float()
        if num_inputs == 1:
            labels_true = torch.pow(features, deg) * w_true
        else:
            labels_true = torch.mm(torch.pow(features, deg), w_true)
        labels = labels_true + torch.randn(size = labels_true.shape) * delta
    return features, labels

测试函数性能

首先查看扰动项较小的时候的数据情况

# 设置随机数种子
torch.manual_seed(420)   

# 扰动项取值为0.01
f, l = tensorGenReg(delta = 0.01)
f
# output :
tensor([[-0.0070,  0.5044,  1.0000],
        [ 0.6704, -0.3829,  1.0000],
        [ 0.0302,  0.3826,  1.0000],
        ...,
        [-0.9164, -0.6087,  1.0000],
        [ 0.7815,  1.2865,  1.0000],
        [ 1.4819,  1.1390,  1.0000]])

# 绘制图像查看结果
plt.subplot(223)
plt.scatter(f[:, 0], l)             # 第一个特征和标签的关系
plt.subplot(224)
plt.scatter(f[:, 1], l)          # 第二个特征和标签的关系

在这里插入图片描述

然后查看扰动项较大时数据情况

# 设置随机数种子
torch.manual_seed(420)   

# 扰动项取值为2
f, l = tensorGenReg(delta = 2)

# 绘制图像查看结果
plt.subplot(223)
plt.scatter(f[:, 0], l)             # 第一个特征和标签的关系
plt.subplot(224)
plt.scatter(f[:, 1], l)          # 第二个特征和标签的关系

在这里插入图片描述

当特征和标签满足二阶关系时候数据表现

# 设置随机数种子
torch.manual_seed(420)   

# 2阶方程
f, l = tensorGenReg(deg = 2)

# 绘制图像查看结果
plt.subplot(223)
plt.scatter(f[:, 0], l)             # 第一个特征和标签的关系
plt.subplot(224)
plt.scatter(f[:, 1], l)          # 第二个特征和标签的关系

在这里插入图片描述

当只有一个特征时数据表现

# 设置随机数种子
torch.manual_seed(420)   

# 2阶方程
f, l = tensorGenReg(w = [1], deg = 2, bias = False)
plt.scatter(f, l)

在这里插入图片描述


47 分类数据集创建方法

和回归模型的数据不同，分类模型数据的标签是离散值。

47.1 手动创建分类数据集


数据生成

在尝试创建分类数据集之前，首先回顾torch.normal创建某种服从正态分布的随机数的创建方法。

torch.randn(4, 2)
# output :
tensor([[ 1.4000,  0.3924],
        [-0.0695, -1.7610],
        [ 0.3227,  1.7285],
        [-0.1107, -1.6273]])

torch.normal(4, 2, size=(10,2))
# output :
tensor([[4.8092, 0.9773],
        [4.4092, 3.3987],
        [1.7446, 6.2281],
        [3.0095, 4.2286],
        [7.8873, 6.5354],
        [3.9286, 4.0315],
        [2.0309, 4.5259],
        [3.6491, 0.7394],
        [3.6549, 5.4767],
        [8.5935, 3.0440]])

接下来尝试创建一个拥有两个特征的三分类的数据集，每个类别包含500条数据，并且第一个类别的两个特征都服从均值为4、标准差为2的正态分布，第二个类别的两个特征都服从均值为-2、标准差为2的正态分布，第三个类别的两个特征都服从均值为-6、标准差为2的正态分布，创建过程如下:

# 设置随机数种子
torch.manual_seed(420)

# 创建初始标记值
num_inputs = 2
num_examples = 500

# 创建自变量簇
data0 = torch.normal(4, 2, size=(num_examples, num_inputs))
data1 = torch.normal(-2, 2, size=(num_examples, num_inputs))
data2 = torch.normal(-6, 2, size=(num_examples, num_inputs))

# 创建标签
label0 = torch.zeros(500)
label1 = torch.ones(500)
label2 = torch.full_like(label1, 2)

# 合并生成最终数据
features = torch.cat((data0, data1, data2)).float()
labels = torch.cat((label0, label1, label2)).long().reshape(-1, 1)

数据探索

features[: 10]
# output :
tensor([[3.9859, 5.0089],
        [5.3407, 3.2343],
        [4.0605, 4.7653],
        [2.9738, 5.4208],
        [7.6183, 4.8705],
        [9.2907, 4.5307],
        [5.8470, 3.1249],
        [8.0364, 6.6997],
        [3.4954, 3.9290],
        [3.8709, 2.8165]])

labels[: 10]
# output :
tensor([[0],
        [0],
        [0],
        [0],
        [0],
        [0],
        [0],
        [0],
        [0],
        [0]])

# 可视化展示
plt.scatter(features[:, 0], features[:, 1], c = labels)

在这里插入图片描述

能够看出，类别彼此交叉情况较少，分类器在此数据集上会有不错表现。当然，若要增加分类器的分类难度，可以将各类的均值压缩，并增加方差，从而增加从二维图像上来看彼此交错的情况。

# 设置随机数种子
torch.manual_seed(420)   

# 创建初始标记值
num_inputs = 2
num_examples = 500

# 创建自变量簇
data0 = torch.normal(3, 2, size=(num_examples, num_inputs))
data1 = torch.normal(0, 2, size=(num_examples, num_inputs))
data2 = torch.normal(-3, 2, size=(num_examples, num_inputs))

# 创建标签
label0 = torch.zeros(500)
label1 = torch.ones(500)
label2 = torch.full_like(label1, 2)

# 合并生成最终数据
features1 = torch.cat((data0, data1, data2)).float()
labels1 = torch.cat((label0, label1, label2)).long().reshape(-1, 1)

# 可视化展示
plt.subplot(121)
plt.scatter(features[:, 0], features[:, 1], c = labels)             
plt.subplot(122)
plt.scatter(features1[:, 0], features1[:, 1], c = labels1)

在这里插入图片描述


47.2 创建生成分类数据的函数

同样，我们将上述创建分类函数的过程封装为一个函数。这里需要注意的是，我们希望找到一个变量可以控制数据整体离散程度，也就是后续建模的难以程度。这里我们规定，如果每个分类数据集中心点较近、且每个类别的点内部方差较大，则数据集整体离散程度较高，反之离散程度较低。在实际函数创建过程中，我们也希望能够找到对应的参数能够方便进行自主调节。


定义创建函数

def tensorGenCla(num_examples = 500, num_inputs = 2, num_class = 3, deg_dispersion = [4, 2], bias = False):
    """分类数据集创建函数。 
    :param num_examples: 每个类别的数据数量
    :param num_inputs: 数据集特征数量
    :param num_class：数据集标签类别总数
    :param deg_dispersion：数据分布离散程度参数，需要输入一个列表，其中第一个参数表示每个类别数组均值的参考、第二个参数表示随机数组标准差。
    :param bias：建立模型逻辑回归模型时是否带入截距
    :return: 生成的特征张量和标签张量，其中特征张量是浮点型二维数组，标签张量是长正型二维数组。
    """
    cluster_l = torch.empty(num_examples, 1)	# 每一类标签张量的形状
    mean_ = deg_dispersion[0]	# 每一类特征张量的均值的参考值
    std_ = deg_dispersion[1]	# 每一类特征张量的方差
    lf = []	# 用于存储每一类特征张量的列表容器
    ll = []	# 用于存储每一类标签张量的列表容器
    k = mean_ * (num_class - 1) / 2		# 每一类特征张量均值的惩罚因子
    
    for i in range(num_class):
        data_temp = torch.normal(i*mean_-k, std_, size=(num_examples, num_inputs))     # 生成每一类张量
        lf.append(data_temp)	# 将每一类张量添加到lf中
        labels_temp = torch.full_like(cluster_l, i)		# 生成类一类的标签
        ll.append(labels_temp)	# 将每一类标签添加到ll中
    features = torch.cat(lf).float()
    labels = torch.cat(ll).long()
    
    if bias == True:
        # 在特征张量中添加一列全是1的列
        features = torch.cat((features, torch.ones(len(features), 1)), 1)
    return features, labels

函数整体结构不复杂，且所使用的方法都是此前介绍过的tensor常用方法，唯一需要注意的是函数对于分布离散程度的控制。函数内部变量k是一个随着均值增加和分类类别数量增加而增加的数值，且分类数量增加对k值增加影响是通过和1取平均后进行惩罚的结果。而i*mean_则是一个随着i增加稳步增量的量，二者相减最终能获得一个整体特征均匀分布在0附近的特征张量。


测试函数性能

在使用函数的过程中，离散度的第一个数值可以理解为簇的大概分布区间，第二个数值可以理解为每个簇的离散程度。

# 设置随机数种子
torch.manual_seed(420)   

# 创建数据
f, l = tensorGenCla(deg_dispersion = [6, 2])          # 离散程度较小
f1, l1 = tensorGenCla(deg_dispersion = [6, 4])        # 离散程度较大

# 绘制图像查看
plt.subplot(121)
plt.scatter(f[:, 0], f[:, 1], c = l)
plt.subplot(122)
plt.scatter(f1[:, 0], f1[:, 1], c = l1)

在这里插入图片描述


48 创建小批量切分函数

在深度学习建模过程中，梯度下降是最常用的求解目标函数的优化方法，而针对不同类型、拥有不同函数特性的目标函数，所使用的梯度下降算法也各有不同。目前为止，我们判断小批量梯度下降（MBGD）是较为“普适”的优化算法，它既拥有随机梯度下降（SGD）的能够跨越局部最小值点的特性，同时又和批量梯度下降（BGD）一样，拥有相对较快的收敛速度（虽然速度略慢与BGD）。而在小批量梯度下降过程中，我们需要对函数进行分批量的切分，因此，在手动实现各类深度学习基础算法之前，我们需要定义数据集小批量切分的函数。

shuffle过程：将原序列乱序排列

l = list(range(5))
l
# output :
[0, 1, 2, 3, 4]

random.shuffle(l)
l
# output :
[3, 2, 0, 1, 4]

批量切分函数的目标就是根据设置的“批数”，将原数据集随机均匀切分。可通过如下函数实现：

def data_iter(batch_size, features, labels):
    """
    数据切分函数
    :param batch_size: 每个子数据集包含多少数据
    :param featurs: 输入的特征张量
    :param labels：输入的标签张量
    :return l：包含batch_size个列表，每个列表切分后的特征和标签所组成 
    """    
    num_examples = len(features)
    indics = list(range(num_examples))
    random.shuffle(indices)
    l=[]	# 空列表用于存储数据
    for i in range(0, num_examples, batch_size):
        j = torch.tensor(indices[i: min(i + batch_size, num_examples)])
        l.append([torch.index_select(features, 0, j), torch.index_select(labels, 0, j)])
    return l

# 设置随机数种子
torch.manual_seed(420)  

# 生成二分类数据集
features, labels = tensorGenCla()       

features[:5]
# output :
tensor([[-4.0141, -2.9911],
        [-2.6593, -4.7657],
        [-3.9395, -3.2347],
        [-5.0262, -2.5792],
        [-0.3817, -3.1295]])

labels
# output :
tensor([[0],
        [0],
        [0],
        ...,
        [2],
        [2],
        [2]])

l = data_iter(10, features, labels)

l[0]	# 查看切分后的第一个数据集 
# output :
[tensor([[ 0.7901,  2.4304],
         [ 4.0788,  3.7885],
         [-1.1552, -0.8829],
         [ 1.3738,  2.3689],
         [-2.1479, -6.6638],
         [-2.5418, -7.9962],
         [-1.0777, -0.7594],
         [ 5.6215,  3.9071],
         [ 3.5896,  3.3644],
         [ 1.2458,  0.0179]]),
 tensor([[1],
         [2],
         [1],
         [1],
         [0],
         [0],
         [1],
         [2],
         [2],
         [1]])]

plt.scatter(l[0][0][:, 0], l[0][0][:, 1], c = l[0][1])

在这里插入图片描述


49 Python模块编写

本节定义的函数将后续课程中将经常使用，因此需要将其封装为一个模块方便后续调用。封装为模块有以下几种基本方法：

  • 打开文本编辑器，将写好并测试完成的函数写入其中，并将文本的拓展名改写为.py；
  • 在spyder或者pycharm中复制相关函数，并保存为.py文件；

然后将文件保存在jupyter主目录下，并取名为torchLearning，后续即可通过import torchLearning进行调用。如果是jupyterlab用户，也可按照如下方式进行编写：

Step 1.打开左侧文件管理栏页，点击新建

在这里插入图片描述

Step 2.在新建目录中，选择Test File

Step 3.在打开的文本编辑器中输入代码

需要保存的函数有：

  • tensorGenReg函数
  • tensorGenCla函数
  • data_iter函数

在这里插入图片描述

Step 4.保存退出，并将文件名改写为torchLearning.py

在这里插入图片描述

然后即可在其他ipy文件中调用，具体调用方法见下一节内容。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

10分钟快速上手DeepSeek！

10分钟快速上手DeepSeek！

DeepSeek 是一款基于命令行和配置文件的数据处理工具，支持多种数据格式（如 CSV、JSON、SQL 等）和多种数据源（如本地文件、数据库、API 等）。 它的核心功能包括： 数据导入与导出：支持从多种数据…
阅读更多...
【现代深度学习技术】深度学习计算 | 延后初始化自定义层

【现代深度学习技术】深度学习计算 | 延后初始化自定义层

【作者主页】Francek Chen 【专栏介绍】 ⌈ ⌈ ⌈PyTorch深度学习 ⌋ ⌋ ⌋ 深度学习 (DL, Deep Learning) 特指基于深层神经网络模型和方法的机器学习。它是在统计机器学习、人工神经网络等算法模型基础上，结合当代大数据和大算力的发展而发展出来的。深度学习最重…
阅读更多...
Redis --- 秒杀优化方案（阻塞队列+基于Stream流的消息队列）

Redis --- 秒杀优化方案（阻塞队列+基于Stream流的消息队列）

下面是我们的秒杀流程： 对于正常的秒杀处理，我们需要多次查询数据库，会给数据库造成相当大的压力，这个时候我们需要加入缓存，进而缓解数据库压力。 在上面的图示中，我们可以将一条流水线的任务拆成两条流水…
阅读更多...
Rust HashMap ：当储物袋遇上物品清单

Rust HashMap ：当储物袋遇上物品清单

开场白：哈希映射的魔法本质 在Rust的奇幻世界里，HashMap就像魔法师的储物袋： 键值对存储 → 每个物品都有专属咒语（键）和实体（值）快速查找 → 念咒瞬间召唤物品动态扩容 → 自动伸展的魔法空间…
阅读更多...
LabVIEW的智能电源远程监控系统开发

LabVIEW的智能电源远程监控系统开发

在工业自动化与测试领域，电源设备的精准控制与远程管理是保障系统稳定运行的核心需求。传统电源管理依赖本地手动操作，存在响应滞后、参数调节效率低、无法实时监控等问题。通过集成工业物联网（IIoT）技术，实现电源设备…
阅读更多...
C# Winform制作一个登录系统

C# Winform制作一个登录系统

using System; using System.Collections; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms;namespace 登录 {p…
阅读更多...
尝试把clang-tidy集成到AWTK项目

尝试把clang-tidy集成到AWTK项目

前言 项目经过一段时间的耕耘终于进入了团队开发阶段，期间出现了很多问题，其中一个就是开会讨论团队的代码风格规范，目前项目代码风格比较混乱，有的模块是驼峰，有的模块是匈牙利，后面经过讨论，…
阅读更多...
Docker技术相关学习三

Docker技术相关学习三

一、Docker镜像仓库管理 1.docker仓库：用于存储和分发docker镜像的集中式存储库，开发者可以将自己创建的镜像推送到仓库中也可以从仓库中拉取所需要的镜像。 2.docker仓库： 公有仓库（docker hub）：任何人都可…
阅读更多...
挑战项目 --- 微服务编程测评系统（在线OJ系统）

挑战项目 --- 微服务编程测评系统（在线OJ系统）

一、前言 1.为什么要做项目 面试官要问项目，考察你到底是理论派还是实战派？ 1.希望从你的项目中看到你的真实能力和对知识的灵活运用。 2.展示你在面对问题和需求时的思考方式及解决问题的能力。 3.面试官会就你项目提出一些问题，或扩展需求…
阅读更多...
Python 与 PostgreSQL 集成：深入 psycopg2 的应用与实践

Python 与 PostgreSQL 集成：深入 psycopg2 的应用与实践

title: Python 与 PostgreSQL 集成：深入 psycopg2 的应用与实践 date: 2025/2/4 updated: 2025/2/4 author: cmdragon excerpt: PostgreSQL 作为开源关系型数据库的佼佼者，因其强大的功能与性能被广泛应用于各种项目中。而 Python 则因其简洁易用的语法、丰富的库和强大的…
阅读更多...
计算机从何而来？计算技术将向何处发展？

计算机从何而来？计算技术将向何处发展？

计算机的前生：机械计算工具的演进 算盘是计算机的起点，它其实是一台“机械式半自动化运算器”。打算盘的“口诀”其实就是它的编程语言，算盘珠就是它的存储器。 第二阶段是可以做四则运算的加法器、乘法器。1642年，法国数学家帕斯…
阅读更多...
【Blazor学习笔记】.NET Blazor学习笔记

【Blazor学习笔记】.NET Blazor学习笔记

我是大标题 我学习Blazor的顺序是基于Blazor University，然后实际内容不完全基于它，因为它的例子还是基于.NET Core 3.1做的，距离现在很遥远了。 截至本文撰写的时间，2025年，最新的.NET是.NET9了都，可能1…
阅读更多...
MapReduce分区

MapReduce分区

目录 1. MapReduce分区1.1 哈希分区1.2 自定义分区 2. 成绩分组2.1 Map2.2 Partition2.3 Reduce 3. 代码和结果3.1 pom.xml中依赖配置3.2 工具类util3.3 GroupScores3.4 结果 参考 本文引用的Apache Hadoop源代码基于Apache许可证 2.0，详情请参阅 Apache许可证2.0。…
阅读更多...
重生之我在异世界学编程之C语言：深入指针篇（上）

重生之我在异世界学编程之C语言：深入指针篇（上）

大家好，这里是小编的博客频道 小编的博客：就爱学编程 很高兴在CSDN这个大家庭与大家相识，希望能在这里与大家共同进步，共同收获更好的自己！！！ 本文目录 引言正文（1）内置数…
阅读更多...
deep generative model stanford lecture note3 --- latent variable

deep generative model stanford lecture note3 --- latent variable

1 Introduction 自回归模型随着gpt的出现取得很大的成功，还是有很多工程上的问题并不是很适合使用自回归模型： 1）自回归需要的算力太大，满足不了实时性要求：例如在自动驾驶的轨迹预测任务中，如果要用纯自回…
阅读更多...
STM32_SD卡的SDIO通信_DMA读写

STM32_SD卡的SDIO通信_DMA读写

本篇，将使用CubeMXKeil，创建一个SD卡的DMA读写工程。 目录 一、简述 二、CubeMX 配置 SDIO DMA 三、Keil 编辑代码 四、实验效果 实现效果，如下图： 一、简述 上篇已简单介绍了SD、SDIO，本篇不再啰嗦，…
阅读更多...
互联网行业常用12个数据分析指标和八大模型

互联网行业常用12个数据分析指标和八大模型

本文目录 前言 一、互联网线上业务数据分析的12个指标 1. 用户数据（4个） (1) 存量（DAU/MAU） (2) 新增用户 (3) 健康程度（留存率） (4) 渠道来源 2. 用户行为数据（4个） (1) 次数/频率…
阅读更多...
【学术投稿-2025年计算机视觉研究进展与应用国际学术会议 (ACVRA 2025)】从计算机基础到HTML开发：Web开发的第一步

【学术投稿-2025年计算机视觉研究进展与应用国际学术会议 (ACVRA 2025)】从计算机基础到HTML开发：Web开发的第一步

会议官网：www.acvra.org 简介 2025年计算机视觉研究进展与应用（ACVRA 2025）将于2025年2月28-3月2日在中国广州召开，将汇聚世界各地的顶尖学者、研究人员和行业专家，聚焦计算机视觉领域的最新研究动态与应用成就。本次…
阅读更多...
【Unity踩坑】Unity项目管理员权限问题（Unity is running as administrator ）

【Unity踩坑】Unity项目管理员权限问题（Unity is running as administrator ）

问题描述： 使用Unity Hub打开或新建项目时会有下面的提示。 解决方法： 打开“本地安全策略”： 在Windows搜索栏中输入secpol.msc并回车，或者从“运行”对话框（Win R，然后输入secpol.msc）启…
阅读更多...
开发板上Qt运行的环境变量的三条设置语句的详解

开发板上Qt运行的环境变量的三条设置语句的详解

在终端中运行下面三句命令用于配置开发板上Qt运行的环境变量： export QT_QPA_GENERIC_PLUGINStslib:/dev/input/event1 export QT_QPA_PLATFORMlinuxfb:fb/dev/fb0 export QT_QPA_FONTDIR/usr/lib/fonts/设置成功后可以用下面的语句检查设置成功没有 echo $QT_QPA…
阅读更多...
最新文章

Copyright @ 2022~2023