pytorch说明

深度学习中的重要概念：

激活函数：

  1. 激活函数的必要性：激活函数不是绝对必须的，但在深度学习中，它们几乎总是被使用。激活函数可以引入非线性，这使得神经网络能够学习更复杂的模式。

  2. 激活函数的位置：激活函数通常放在线性层（如全连接层）之后。这样做可以引入非线性，否则，无论有多少层，整个网络的运算都可以被简化为一个单一的线性变换。

  3. 激活函数的选择：激活函数的选择和放置通常取决于具体的应用和网络架构。有些网络架构可能会在某些层之前或之后使用不同的激活函数。

损失函数：

  1. 损失函数的作用：损失函数用于衡量模型的预测与真实值之间的差异。训练过程中，目标是最小化损失函数，从而提高模型的预测准确性。

  2. 常用的损失函数：

    • 均方误差（MSE）：常用于回归问题。
    • 交叉熵损失（Cross-Entropy Loss）：常用于分类问题。
    • Hinge Loss：用于支持向量机（SVM）。
    • Categorical Cross-Entropy Loss：用于多分类问题。
    • Binary Cross-Entropy Loss：用于二分类问题。

  3. 分类问题和回归问题的损失函数：

    • 分类问题：通常使用交叉熵损失，特别是对于多分类问题使用Categorical Cross-Entropy Loss，对于二分类问题使用Binary Cross-Entropy Loss。
    • 回归问题：通常使用均方误差损失。

前向传播和反向传播：

  1. 前向传播：指的是数据在神经网络中的正向流动，即从输入层经过每一层的计算，直到输出层。

  2. 反向传播：是与前向传播相对的过程，用于计算损失函数相对于网络参数的梯度。这是通过链式法则完成的，从输出层开始，逆向传递至输入层。

  3. 为什么使用PyTorch要定义前向传播：在PyTorch中，定义forward函数是为了指定模型如何接收输入并产生输出。PyTorch自动处理反向传播，但需要用户定义前向传播的逻辑。

  4. 梯度计算的位置：梯度计算是在反向传播的过程中进行的。在前向传播过程中，我们计算模型的输出；在反向传播过程中，我们计算如何调整模型的参数以减少损失。

重要概念，构成深度学习的基础： 

  1. 神经网络架构：

    包括不同类型的网络层（如卷积层、循环层、池化层等）和它们如何组合在一起形成完整的模型。

  2. 权重和偏置：

    神经网络中的参数，权重决定了连接的强度，偏置则用于调整激活输出的阈值。

  3. 正则化：

    技术，如L1和L2正则化，用于防止模型过拟合，通过惩罚大的权重值来鼓励更简单的模型。

  4. 优化算法：

    如梯度下降（及其变体，如SGD、Adam、RMSprop等），用于在训练过程中更新模型的参数。

  5. 批量处理：

    将数据分成小批量进行训练，可以提高内存效率并有助于提高模型的泛化能力。

  6. 过拟合与欠拟合：

    过拟合发生在模型在训练数据上表现很好，但在新数据上表现差；欠拟合则是模型在训练数据上表现不足。

  7. 超参数：

    模型训练前需要设置的参数，如学习率、批量大小、训练轮数等，它们对模型性能有重要影响。

  8. 特征提取：

    从原始数据中提取有用信息的过程，特征的好坏直接影响模型的性能。

  9. 数据增强：

    通过对训练数据进行变换（如旋转、缩放、裁剪等）来增加数据多样性，减少过拟合。

  10. 模型评估：

    使用验证集和测试集来评估模型性能，常用的评估指标包括准确率、精确率、召回率、F1分数等。

  11. 迁移学习：

    利用在一个任务上训练好的模型来解决另一个相关任务的技术。

  12. 模型部署：

    将训练好的模型集成到应用程序中，使其能够对新数据做出预测。

  13. 计算图：

    描述了操作和它们相互之间依赖关系的图，用于自动微分和梯度计算。

  14. 损失景观和优化景观：

    损失函数和优化算法在参数空间中的表现，包括局部最小值、全局最小值和鞍点。

  15. 注意力机制：

    一种让模型集中于输入数据的特定部分的技术，广泛应用于序列模型中。

自动求导机制： 

  1. requires_grad 属性：这个属性用来标记变量是否需要计算梯度。如果一个变量的 requires_grad 为 True，那么在反向传播时会计算其梯度。如果所有输入变量都不需要梯度，则输出也不需要梯度。

  2. volatile 属性：用于纯粹的推理模式，可以提高效率，因为它使用最少的内存。如果输入是 volatile，那么输出也是 volatile，且 requires_grad 为 False。volatile 属性比 requires_grad 更容易传递。

  3. 自动求导的编码历史：每个变量都有一个 .creator 属性，指向创建它的函数。这些函数形成了一个有向无环图（DAG），用于在反向传播时计算梯度。

  4. In-place 操作：在自动求导中，不鼓励使用 in-place 操作，因为它们可能会覆盖梯度计算所需的值，或者需要重写计算图。

  5. In-place 正确性检查：每个变量有一个版本计数器，每次使用时递增。如果版本计数器的值大于保存的值，将引发错误。

示例：

假设我们有一个简单的神经网络模型，我们想要训练它。在这个过程中，我们会使用 requires_grad 来控制梯度的计算。

import torch 
import torch.nn as nn 
# 定义一个简单的模型 
model = nn.Sequential( nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 2) ) 
# 假设我们已经有了一些数据 
inputs = torch.randn(1, 10, requires_grad=True)
# 输入数据，需要梯度
outputs = model(inputs) 
# 前向传播 
# 假设我们有正确的输出 
targets = torch.tensor([1.0, 0.0])
# 计算损失 
loss = (outputs - targets).pow(2).sum() 
# 均方误差损失 # 反向传播，计算梯度 
loss.backward() 
# 打印第一个线性层的梯度 
print(model[0].weight.grad)

 运行结果：

在这个例子中，我们创建了一个简单的模型，并对其进行了前向传播。我们设置了输入数据的 requires_grad 属性为 True，这样在计算损失并调用 backward() 方法时，PyTorch 会自动计算梯度。最后，打印了第一个线性层的梯度，这是自动求导机制的直接应用。

这段文字主要介绍了在使用PyTorch和CUDA进行深度学习时的一些最佳实践和概念。我会用简单的语言解释这些概念，并提供一个示例。

CUDA语义解释：

  1. GPU选择：torch.cuda会记录当前选择的GPU，所有通过它创建的张量都会在该GPU上。

  2. 设备无关操作：一旦张量被分配到某个GPU，你可以在任何设备上对其进行操作，结果会自动放在与张量相同的设备上。

  3. 跨GPU操作限制：默认情况下，不支持在不同GPU上的张量之间进行操作，除非启用了对等存储器访问。

  4. 上下文管理器：使用torch.cuda.device可以临时更改所选的GPU设备。

示例：

import torch

# 选择GPU 0
x = torch.cuda.FloatTensor(1)

# 将一个CPU上的张量复制到GPU 0
y = torch.FloatTensor(1).cuda()

# 使用上下文管理器选择GPU 1
with torch.cuda.device(1):
    # 在GPU 1上创建张量a
    a = torch.cuda.FloatTensor(1)
    
    # 将CPU上的张量复制到GPU 1
    b = torch.FloatTensor(1).cuda()
    
    # 张量a和b都在GPU 1上，可以进行操作
    c = a + b  # c也在GPU 1上

    # 尝试将GPU 0上的x和GPU 1上的y相加，需要先复制到同一个GPU
    z = x.cuda(1) + y.cuda(1)  # z现在也在GPU 1上

# 即使在GPU 1的上下文中，也可以指定将张量分配到其他GPU
d = torch.randn(2).cuda(2)  # d在GPU 2上

最佳实践：

  1. 固定内存缓冲区：使用pin_memory()方法可以提高从CPU到GPU的数据传输速度。

  2. 异步GPU副本：一旦固定了张量，可以使用异步复制来提高效率。

  3. DataLoader的固定内存：通过设置pin_memory=True，可以让DataLoader返回固定内存中的batch。

  4. 使用nn.DataParallel替代多进程：在多GPU环境中，使用DataParallel可以更简单地并行化模型。

  5. 多进程注意事项：使用多进程来利用CUDA模型时，需要特别注意，以避免错误或未定义的行为。

示例：

# 假设我们有一个简单的模型 
model = torch.nn.Linear(10, 5).cuda() 
# 创建一个固定内存的张量 
input_data = torch.randn(32, 10).pin_memory() 
# 异步复制到GPU input_data_gpu = input_data.cuda(async=True) 
# 进行前向传播 output = model(input_data_gpu) 
# 使用DataLoader时设置pin_memory=True 
from torch.utils.data import DataLoader,TensorDataset 
dataset = TensorDataset(torch.randn(100, 10)
torch.randint(0, 2, (100,)))
dataloader = DataLoader(dataset, batch_size=32, pin_memory=True) 
for inputs,labels in dataloader:
# inputs已经在固定内存中，可以直接用于GPU操作 
    outputs = model(inputs.cuda())

这个示例展示了如何在PyTorch中使用固定内存和异步复制来提高数据传输的效率，以及如何使用DataLoader的pin_memory选项。

扩展 torch.autograd

  1. 继承 Function 类：要扩展自动求导系统，你需要创建一个新的操作（Operation），这需要继承class Function。

  2. 实现三个方法：

    • __init__：如果操作需要额外的参数，可以在这个方法中初始化。
    • forward：执行操作的代码，参数是Variable，返回值可以是Variable或Variable的元组。
    • backward：计算梯度的方法，参数是传回操作的梯度，返回值是每个输入的梯度。

示例：

假设我们要实现一个简单的平方操作：

import torch

class SquareFunction(torch.autograd.Function):
    @staticmethod
    def forward(ctx, input):
        ctx.save_for_backward(input)  # 保存输入用于backward
        return input ** 2

    @staticmethod
    def backward(ctx, grad_output):
        input, = ctx.saved_tensors  # 获取保存的输入
        return 2 * input * grad_output  # 梯度是2倍的输入值乘以输出的梯度

使用这个自定义操作：

def square(input):
    return SquareFunction.apply(input)

x = torch.tensor([2.0], requires_grad=True)
y = square(x)
print(y)  # 输出 4
y.backward()  # 计算梯度
print(x.grad)  # 输出 4，因为梯度是 2 * x

扩展 torch.nn

  1. 使用 modules：当你需要保存参数和buffer时，使用nn.Module。

  2. 实现两个方法：

    • __init__：初始化模块的参数。
    • forward：使用Function执行操作。

示例：

使用上面实现的SquareFunction，我们可以创建一个nn.Module：

class SquareModule(torch.nn.Module):
    def __init__(self):
        super(SquareModule, self).__init__()

    def forward(self, x):
        return square(x)  # 使用自定义的SquareFunction

使用这个模块：

square_module = SquareModule()
x = torch.tensor([2.0], requires_grad=True)
y = square_module(x)
print(y)  # 输出 4
y.backward()  # 计算梯度
print(x.grad)  # 输出 4

测试梯度正确性

使用torch.autograd.gradcheck可以检查你的梯度实现是否正确：

from torch.autograd import gradcheck

input = torch.randn(2, 2, requires_grad=True)
test = gradcheck(SquareFunction.apply, input, eps=1e-6, atol=1e-4)
print(test)  # 如果梯度正确，输出 True

这个示例展示了如何扩展PyTorch的自动求导系统和nn模块，并提供了一个简单的平方操作示例

结果：

多进程编程

主要概念：

  1. torch.multiprocessing：是Python的multiprocessing模块的扩展，它允许在进程间共享张量。

  2. 共享张量：当一个Variable被发送到另一个进程时，它的data和grad.data都会被共享。

  3. CUDA张量共享：仅在Python 3中使用spawn或forkserver启动方法时才支持。

  4. 避免死锁：多进程编程时，要避免死锁，特别是由于后台线程引起的死锁。

  5. 重用缓冲区：在多进程中，应重用通过队列传递的张量，以避免不必要的内存复制。

  6. 异步多进程训练：可以使用torch.multiprocessing进行异步训练，参数可以共享或定期同步。

  7. 使用队列传递对象：建议使用multiprocessing.Queue在进程间传递PyTorch对象。

  8. Hogwild：一种并行训练方法，允许多个进程同时更新共享模型参数。

示例：

下面是一个简单的示例，展示了如何使用torch.multiprocessing来并行执行一个简单的计算任务：

# my_module.py
import torch

def compute_sum(x):
    return torch.sum(x)

# main.py
import torch.multiprocessing as mp
from my_module import compute_sum  # 确保从模块中导入函数

def main():
    tensors = [torch.randn(10) for _ in range(4)]
    with mp.Pool(processes=4) as pool:
        results = pool.map(compute_sum, tensors)
        for result in results:
            print(result)

if __name__ == '__main__':
    main()

在这个示例中，我们定义了一个compute_sum函数，它接受一个张量并返回它的和。然后，我们创建了4个随机张量，并使用mp.Pool来创建一个进程池。通过pool.map方法，我们可以并行地计算每个张量的和。

注意事项：

  • 使用if __name__ == '__main__':来保护代码，以确保它只在主进程中执行，而不是在每个子进程中执行。
  • 当使用fork启动方法时，要注意全局解释器锁（GIL）和共享内存的问题。
  • 在多进程编程中，要特别注意避免死锁和内存管理问题。

序列化pytorch模型：

是将对象的状态信息转换为可以存储或传输的形式的过程。在PyTorch中，序列化通常用于保存和加载模型。以下是一些关于序列化PyTorch模型的最佳实践：

推荐方法：保存和加载模型参数

  1. 保存模型参数： 使用state_dict()方法可以获取模型的所有参数，然后使用torch.save()保存到文件。

    torch.save(the_model.state_dict(), 'model_parameters.pth')

  2. 加载模型参数： 首先，你需要实例化模型（这会恢复模型架构）。然后，使用load_state_dict()方法加载保存的参数。

    the_model = TheModelClass(*args, **kwargs)
the_model.load_state_dict(torch.load('model_parameters.pth'))

    优点：

    • 灵活性：只保存参数，不关心模型的类定义或目录结构，可以在任何具有相同模型架构的项目中使用。
    • 兼容性：参数字典可以在不同的模型架构或不同的代码库中重用。

         缺点：

  1. 需要重新实例化模型：在使用模型参数之前，需要先实例化模型的架构。如果模型的构造函数或参数设置较为复杂，这可能会增加一些额外的工作。

  2. 状态丢失：除了模型参数之外的其他状态（如训练轮次、优化器状态等）不会保存。如果需要这些额外的状态信息，需要单独处理。

  3. 依赖于模型类：加载参数时需要有正确的模型类定义。如果模型类在之后的开发中被修改或重命名，可能会导致加载失败。

另一种方法：保存和加载整个模型

  1. 保存整个模型： 直接保存模型对象，包括其参数和架构。

    torch.save(the_model, 'complete_model.pth')

  2. 加载整个模型： 直接从文件加载模型对象。

    the_model = torch.load('complete_model.pth')
    优点：
1. 简便性：可以直接保存和加载整个模型对象，包括其参数、架构以及优化器状态等，无需单独处理。

2. 保持状态：模型的额外状态（如训练轮次、优化器状态）也会被保存和恢复，这对于恢复训练非常有用。

3. 无需重新实例化：加载模型时，不需要担心模型的构造和初始化问题，直接从保存的状态中恢复。

4. 适用于复杂模型：对于具有复杂依赖或多组件的模型，保存整个模型可以避免重新实例化时的复杂性。

5. 快速迁移：在需要快速迁移模型到不同环境或项目时，只需加载整个模型，而不需要关心模型的具体实现细节。

缺点：
1.耦合性：保存的数据与特定的类和目录结构绑定，如果模型类或项目结构发生变化，可能会导致序列化的数据无法使用。
2.重构风险：在项目重构后，加载整个模型可能会遇到问题，因为依赖的类和方法可能已经改变。

示例

假设我们有一个简单的模型：

class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear = torch.nn.Linear(10, 5)

    def forward(self, x):
        return self.linear(x)

使用推荐的方法保存和加载模型参数：

# 保存模型参数
model = SimpleModel()
model_path = 'simple_model_parameters.pth'
torch.save(model.state_dict(), model_path)

# 加载模型参数
model = SimpleModel()  # 实例化一个新的模型
model.load_state_dict(torch.load(model_path))

使用第二种方法保存和加载整个模型：

# 保存整个模型
complete_model_path = 'simple_complete_model.pth'
torch.save(model, complete_model_path)

# 加载整个模型
model = torch.load(complete_model_path)

注意事项

  • 当使用torch.load()加载模型时，确保在调用之前已经实例化了模型对象。
  • 如果使用GPU训练模型，可以使用map_location参数将模型参数映射到CPU或指定的GPU。
  • 保存和加载模型时，注意文件路径和模型的版本兼容性。

通过遵循这些最佳实践，可以确保模型的序列化过程既灵活又安全。

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

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

相关文章

阿里云产品流转

阿里云产品流转

本文主要记述如何使用阿里云对数据进行流转，这里只是以topic流转（再发布）为例进行说明，可能还会有其他类型的流转，不同服务器的流转也可能会不一样，但应该大致相同。 1 创建设备 具体细节可看：…
阅读更多...
免费的AI抠图工具 毫秒级抠图 离线可用 -鲜艺AI抠图

免费的AI抠图工具 毫秒级抠图 离线可用 -鲜艺AI抠图

鲜艺AI抠图是一款免费的AI抠图工具，不登录、不联网，内嵌 AI 模型，快至毫秒级抠图，支持批量抠图，支持点击按钮选择图片、拖入图片、粘贴图片、粘贴图片链接、从网页拖入图片，支持Windows和macos，…
阅读更多...
Vue el-input 限制输入内容

Vue el-input 限制输入内容

&#x1f914;日常项目中经常遇到既要el-input的样式&#xff0c;又要el-input-number限制&#xff0c;所以需要绑定input事件进行约束输入限制。 以下使用自定义指令进行约束el-input输入的值&#xff0c;便于后期统一管理和拓展。 预览 代码 <!DOCTYPE html> <ht…
阅读更多...
使用 NumPy 及其相关库（如 pandas、scikit-learn 等）时，由于 NumPy 的版本不兼容或者某些依赖库与 NumPy 的版本不匹配

使用 NumPy 及其相关库（如 pandas、scikit-learn 等）时，由于 NumPy 的版本不兼容或者某些依赖库与 NumPy 的版本不匹配

题意&#xff1a; numpy.dtype size changed, may indicate binary incompatibility. Expected 96 from C header, got 88 from PyObject 问题背景&#xff1a; I want to call my Python module from the Matlab. I received the error: Error using numpy_ops>init thi…
阅读更多...
Go 初始化一个字典value是列表

Go 初始化一个字典value是列表

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
react的解构赋值

react的解构赋值

我最近在用react讨生活。我的感觉&#xff0c;react开发效率不高。这当然应该是我还不熟悉react的缘故。但是&#xff0c;在阅读react代码过程中&#xff0c;其中一个容易困惑的地方是它到处充斥着的解构赋值。当然了&#xff0c;解构赋值并不是React特有的功能&#xff0c;而是…
阅读更多...
秋招Java后端开发冲刺——MyBatisPlus总结

秋招Java后端开发冲刺——MyBatisPlus总结

一、 基本知识 1. 介绍 yBatis-Plus 是一个 MyBatis 的增强工具&#xff0c;在 MyBatis 的基础上增加了大量功能和简化操作&#xff0c;以提高开发效率。 2. 特点 无侵入&#xff1a;只做增强不做改变&#xff0c;引入它不会对现有项目产生影响。依赖少&#xff1a;仅仅依赖 …
阅读更多...
【VS2019】安装下载库HtmlAgilityPack，可解析 HTML （图文详情）

【VS2019】安装下载库HtmlAgilityPack，可解析 HTML （图文详情）

目录 0.背景 1.环境 2.详细步骤 0.背景 项目需要&#xff0c;搭建WCF服务&#xff0c;需求是输入一个string类型字符串&#xff08;网页代码&#xff0c;如<html><body><p>Hello, <b>World</b>!</p></body></html>&#xf…
阅读更多...
华为配置蓝牙终端定位实验

华为配置蓝牙终端定位实验

个人主页&#xff1a;知孤云出岫 目录 配置蓝牙终端定位示例 业务需求 组网需求 数据规划 配置思路 配置注意事项 操作步骤 配置文件 配置蓝牙终端定位示例 组网图形 图1 配置蓝牙终端定位示例组网图 业务需求组网需求数据规划配置思路配置注意事项操作步骤配置文件 业…
阅读更多...
NAT地址转换+多出口智能选路，附加实验内容

NAT地址转换+多出口智能选路，附加实验内容

本章主要讲&#xff1a;基于目标IP、双向地址的转换 注意&#xff1a;基于目标NAT进行转换 ---基于目标IP进行地址转换一般是应用在服务器端口映射&#xff1b; NAT的基础知识 1、服务器映射 服务器映射是基于目标端口进行转换&#xff0c;同时端口号也可以进行修改&…
阅读更多...
力扣每日一题：3011. 判断一个数组是否可以变为有序

力扣每日一题：3011. 判断一个数组是否可以变为有序

力扣官网&#xff1a;前往作答&#xff01;&#xff01;&#xff01;&#xff01; 今日份每日一题&#xff1a; 题目要求&#xff1a; 给你一个下标从 0 开始且全是 正 整数的数组 nums 。 一次 操作 中&#xff0c;如果两个 相邻 元素在二进制下数位为 1 的数目 相同 &…
阅读更多...
Manim的代码练习02：在manim中Dot ,Arrow和NumberPlane对象的使用

Manim的代码练习02：在manim中Dot ,Arrow和NumberPlane对象的使用

Dot&#xff1a;指代点对象或者表示点的符号。Arrow&#xff1a;指代箭头对象&#xff0c;包括直线上的箭头或者向量箭头等。NumberPlane&#xff1a;指代数轴平面对象&#xff0c;在Manim中用来创建包含坐标轴的数学坐标系平面。Text&#xff1a;指代文本对象&#xff0c;用来…
阅读更多...
WEB前端02-HTML5基础(02)

WEB前端02-HTML5基础(02)

7.表格标签 在基本表格结构中&#xff0c;表格标题、项目表头和数据资料构成了表格基本结构三个要素。 table标签&#xff1a;定义表格整体 <caption>我的标题</caption>&#xff1a;表格的标题tr标签&#xff1a;定义表格的行 height&#xff1a;设置行的高度…
阅读更多...
探索 Prompt 的世界：让你的 AI 更智能

探索 Prompt 的世界：让你的 AI 更智能

探索 Prompt 的世界&#xff1a;让你的 AI 更智能 引言什么是 Prompt&#xff1f;Prompt 的重要性如何编写有效的 Prompt1. 清晰明确2. 包含关键细节3. 提供上下文 实践中的 Prompt 技巧1. 多次迭代2. 实验不同风格3. 结合实际应用 总结 引言 随着人工智能&#xff08;AI&…
阅读更多...
卸载wps office的几种方法收录

卸载wps office的几种方法收录

​ 第一种方法: 1.打开【任务管理器】&#xff0c;找到相关程序&#xff0c;点击【结束任务】。任务管理器可以通过左下角搜索找到。 2.点击【开始】&#xff0d;【设置】&#xff0d;【应用】&#xff0d;下拉找到WPS应用&#xff0c;右键卸载&#xff0c;不保留软件配置 …
阅读更多...
Java 设计模式系列：解释器模式

Java 设计模式系列：解释器模式

简介 解释器模式是一种行为型设计模式&#xff0c;它提供了一种构建抽象语法树的机制&#xff0c;并定义了如何解释这棵树。解释器模式属于编译原理中的语法制导翻译的范畴。 如上图&#xff0c;设计一个软件用来进行加减计算。我们第一想法就是使用工具类&#xff0c;提供对应…
阅读更多...
【微信小程序知识点】getApp()全局数据共享，页面间通信，组件间通信

【微信小程序知识点】getApp()全局数据共享，页面间通信，组件间通信

getApp()-全局数据共享 在小程序中&#xff0c;可以通过getApp()方法获取到小程序全局唯一的App实例。因此在App()方法中添加全局共享的数据&#xff0c;方法&#xff0c;从而实现页面&#xff0c;组件的数据传值。 // app.js App({//全局共享的数据globalData: {token: &qu…
阅读更多...
prompt第二讲-langchain实现中英翻译助手

prompt第二讲-langchain实现中英翻译助手

文章目录 prompt模板 (prompt template)langchain 中的prompt模板 (prompt template)langchain实现中英翻译助手 prompt模板 (prompt template) 开篇我介绍了在llm中&#xff0c;通常输入的那个字符串会被我们称之为prompt&#xff0c;下面就是一个中英文翻译助手的prompt例子…
阅读更多...
从“Hello，World”谈起（C++入门）

从“Hello，World”谈起（C++入门）

前言 c的发展史及c能干什么不能干什么不是我们今天的重点&#xff0c;不在这里展开&#xff0c;有兴趣的朋友可以自行查阅相关资料。今天我们主要是围绕c的入门程序&#xff0c;写一个“hello&#xff0c;world”&#xff0c;并且围绕这个入门程序简单介绍一下c和c的一些语法&…
阅读更多...
windows USB 设备驱动开发-USB 功能控制器驱动开发(二)

windows USB 设备驱动开发-USB 功能控制器驱动开发(二)

USB 功能客户端驱动程序使用的 UFX 对象和句柄 USB 函数类扩展 (UFX) 使用 WDF 对象功能来定义这些特定于 USB 的 UFX 对象。 重要的 API UfxDeviceCreateUfxEndpointCreate USB 函数类扩展 (UFX) 使用 WDF 对象功能来定义这些特定于 USB 的 UFX 对象。 这些对象是 WDF 对…
阅读更多...
最新文章

Copyright @ 2022~2023