散装码农,AI人工智能的基础知识

CUDA（Compute Unified Device Architecture）是由NVIDIA公司开发的一种并行计算平台和编程模型,主要应用于该公司生产的GPU（图形处理器）。它允许开发者使用支持CUDA的编程语言（如C、C++、Fortran等）来编写在GPU上运行的程序,以利用GPU强大的并行计算能力。

CUDA的主要特点和优势包括:

并行计算: CUDA允许在GPU上进行大规模并行计算,可以大幅提高某些类型任务(如科学计算、机器学习等)的运行速度。

易用性: CUDA提供了一组扩展的编程语言(如CUDA C/C++),使得开发人员可以较容易地编写和优化GPU程序。

可扩展性: CUDA程序可以在不同规模和性能的NVIDIA GPU上运行,具有良好的可扩展性。

生态系统: NVIDIA提供了丰富的CUDA工具和库(如cuBLAS、cuDNN等),加速了GPU程序的开发。

广泛应用: CUDA已被广泛应用于科学计算、机器学习、图像处理、视频编码等领域,尤其在深度学习领域发挥了重要作用。

总之,CUDA通过利用GPU的并行计算架构,为开发者提供了一种开发高性能应用程序的强大工具,极大地推动了GPU计算的发展和应用。它已成为许多领域不可或缺的加速计算平台。

CUDA实际上包含了SDK（Software Development Kit）和API（Application Programming Interface）两个部分。

CUDA SDK：CUDA SDK是一套完整的开发工具包,包括编译器、调试器、性能分析工具、数学库等。它允许开发者在支持CUDA的硬件上开发、调试和优化基于GPU的应用程序。CUDA SDK提供了一个集成的开发环境,使开发人员能够更高效地开发CUDA应用程序。
CUDA API：CUDA API是一组用于与GPU交互的编程接口。它包括一组扩展的编程语言（如CUDA C/C++）和函数库,允许开发者在GPU上分配内存、传输数据、启动内核函数等。CUDA API提供了对GPU硬件的抽象,使开发人员能够专注于并行算法的实现,而不必过多关注底层硬件细节。

因此,从开发者的角度来看,CUDA主要是一个SDK,因为它提供了一整套开发GPU应用程序所需的工具和组件。同时,从编程的角度来看,CUDA也提供了一组API,允许开发者在其应用程序中与GPU进行交互和数据传输。

总之,CUDA作为一个并行计算平台,包含了SDK和API两个紧密相关的部分,共同为GPU编程提供了强大的支持。

CUDNN（CUDA Deep Neural Network library）是NVIDIA提供的一个用于深度神经网络的GPU加速库。它是CUDA工具包的一部分,旨在提高深度学习应用程序的性能。CUDNN提供了一组经过优化的深度学习基元,如卷积、池化、归一化和激活函数等,可以显著加快深度神经网络的训练和推理速度。

CUDNN的主要特点和优势包括:

高性能: CUDNN提供了经过优化的深度学习基元实现,充分利用了GPU的并行计算能力,可以显著提高深度神经网络的运行速度。
易用性: CUDNN提供了简单易用的API接口,可以方便地集成到现有的深度学习框架中,如TensorFlow、PyTorch、Caffe等。
多种神经网络支持: CUDNN支持各种类型的深度神经网络,包括卷积神经网络（CNN）、递归神经网络（RNN）、长短期记忆网络（LSTM）等。
自动优化: CUDNN可以根据硬件配置和网络结构自动选择最优的算法和参数,简化了性能优化的过程。
持续更新: NVIDIA会持续更新CUDNN,提供新的功能和性能改进,以跟上深度学习技术的发展。

CUDNN的工作原理是将深度学习基元的实现从深度学习框架中抽离出来,并提供了经过优化的GPU实现。当深度学习框架调用这些基元时,实际上是在调用CUDNN库提供的高度优化的GPU实现,从而获得显著的性能提升。

总之,CUDNN作为一个专用于深度学习的GPU加速库,通过提供经过优化的深度学习基元实现,显著提高了深度神经网络的性能。它已成为加速深度学习应用程序的重要工具,被广泛应用于学术研究和工业界。

关于NLP里tokens的解释

在自然语言处理(NLP)领域,特别是在基于 Transformer 架构的语言模型中,"tokens"(标记)通常是指构成输入序列的基本单元。它可以是一个字、一个词、一个子词或者一个字符,具体取决于所使用的分词方法。

在传统的 NLP 任务中,"token"通常指的是单个的词。例如,句子"I love AI"包含三个 tokens:"I"、"love"和"AI"。

当我们说"模型支持 8k tokens 上下文"时,这意味着:

假设你正在读一本书,现在你读到了第100页。为了真正理解第100页的内容,仅仅读这一页可能是不够的,你可能需要回顾前面的几页,甚至是前面的几章,以便更好地理解当前页面的内容。这些你需要回顾的前面的内容,就是所谓的"上下文"。

现在,假设你有一个超强的记忆力,你可以在读第100页时,同时考虑前面99页的内容。这意味着你有100页的"上下文"来帮助你理解第100页。显然,与只记得前面10页或20页相比,记住前面99页可以让你对第100页有更深入、更全面的理解。

将这个例子与语言模型联系起来:

每一页可以看作是一个"token"(假设每页只有一个词)。

你正在读的第100页就是模型当前要处理的 token。

你的"超强记忆力"就相当于模型的上下文长度。

因此,当我们说"模型支持 8k tokens 上下文"时,这就像说你在读第8000页时,可以同时记住并考虑前面的7999页。这是一个非常大的"记忆力",可以帮助模型更好地理解和生成文本。

当然,在实际应用中,模型处理的是更细粒度的 tokens(通常是词或子词),而不是整页的内容。但无论如何,更长的上下文意味着模型可以考虑更多的信息,从而做出更准确、更连贯的预测或生成。

关于tokens的计费

在大多数提供 AI 语言模型服务的平台中,按 tokens 计费通常包括用户的输入和 AI 的输出,也就是说,两者都会被计入费用。

人工智能书推荐

TensorFlow VS PyTorch

安装和配置

TensorFlow和PyTorch的安装和配置过程都相对简单。它们都支持多个操作系统，包括Windows、Linux和macOS。TensorFlow支持Python、C++、Java和Go等编程语言，而PyTorch主要使用Python。两个框架的文档和社区资源非常丰富，可以帮助用户解决安装和配置过程中遇到的问题。

模型定义和训练

TensorFlow和PyTorch在模型定义和训练方面有一些不同。在TensorFlow中，模型的定义和计算图建立在静态图的基础上，用户需要显式地定义图中的节点和操作。这种方式的好处是可以对图进行高级优化和部署。而在PyTorch中，模型的定义和计算图是动态的，用户可以根据需要灵活地定义和修改计算图。这种动态图的方式使得PyTorch更容易进行调试和实验。

在训练过程中，TensorFlow使用会话（Session）来管理计算图和变量。用户需要明确地指定变量的初始化、损失函数、优化器等。PyTorch则使用动态图来追踪变量和操作的计算过程，用户只需简单地定义前向传播过程，然后通过调用反向传播函数即可进行梯度计算和参数更新。

灵活性和可扩展性

在灵活性和可扩展性方面，PyTorch表现更加出色。PyTorch的设计理念强调易用性和灵活性，用户可以方便地对模型进行修改和扩展。PyTorch还提供了更多的高级特性，如动态图、自动微分和自定义操作等，使得用户可以更好地控制模型的计算过程。

TensorFlow虽然在初始学习成本上可能相对高一些，但它在大规模分布式训练和部署等方面表现出更高的可扩展性。TensorFlow的静态图设计使得其能够对计算图进行高效优化和分布式运算。此外，TensorFlow还提供了一系列用于大规模训练和部署的工具和库。

社区支持

TensorFlow和PyTorch都有庞大的用户社区和丰富的文档资源，这使得学习和使用这两个框架变得更加容易。TensorFlow在推出之初就受到了很多大公司的青睐，并得到了广泛应用。PyTorch则是由Facebook AI Research开发并开源的，近年来也得到了越来越多学术界和工业界的支持。两个框架都拥有活跃的社区，用户可以在社区中寻求帮助、交流经验和分享代码。此外，两个框架都有很多开源项目和示例代码可供学习和参考。

何为AI模型

AI模型是一种计算机程序，它通过学习和分析大量的数据，尤其是输入和输出的对应关系，来模拟人类的智能行为。它可以用于各种任务，如图像识别、语音识别、自然语言处理等。

简单来说，AI模型就像是一个智能工具，它可以通过大量的训练数据学习并理解事物的规律和模式。类似于我们人类学习新知识的过程，AI模型会通过观察和分析数据来提取特征，并建立一个能够预测和推理的模型。这个模型在训练完成后就可以被用来处理新的数据，并作出类似人类的决策或回答问题。

举个例子，如果我们想让AI模型学会识别猫的图片，我们可以给它展示大量的猫的图片，并告诉它这些图片都是猫。AI模型会通过分析这些图片的特征，比如猫的耳朵、眼睛、鼻子等，来学会辨别猫的图片。然后，当我们给它一张新的图片时，AI模型可以根据之前学到的知识判断这张图片是否是猫。

总的来说，AI模型就是一个能够通过学习数据来模拟人类智能行为的程序，它可以帮助我们解决各种复杂的问题，并提供智能化的服务。

学习AI模型开发需要掌握以下基础知识

1. 编程语言：首先，你需要熟悉至少一种编程语言，比如Python或Java。这些语言在AI开发中广泛使用，因为它们具有丰富的库和工具，可以简化开发过程。

2. 数据处理和分析：了解数据处理和分析的基本概念是非常重要的。你需要学会如何清洗、转换和准备数据，以便用于训练和评估AI模型。

3. 数学和统计学：AI模型的许多算法和技术都基于数学和统计学原理。掌握线性代数、微积分、概率论和统计学等基础数学概念对于理解和实现AI模型是必要的。

4. 机器学习算法：学习机器学习算法是开发AI模型的关键。你需要了解常见的机器学习算法，如线性回归、逻辑回归、决策树、支持向量机和神经网络等。掌握这些算法的原理、应用场景和实现方式将帮助你构建和训练AI模型。

5. 深度学习：深度学习是一种特殊的机器学习方法，它使用神经网络模型来处理复杂的任务。学习深度学习需要了解神经网络的基本原理、常见的深度学习架构（如卷积神经网络、循环神经网络）以及深度学习框架（如TensorFlow、PyTorch）的使用。

6. 数据集和训练：了解如何准备和使用数据集进行模型训练是至关重要的。你需要学习如何选择、标记和划分数据集，以及如何进行训练和验证。

7. 模型评估和优化：了解如何评估和优化AI模型的性能也是必不可少的。你需要学习如何选择合适的评估指标，如准确率、精确率、召回率等，并掌握调整模型参数、处理过拟合和欠拟合等常见问题的技巧。

除了上述基础知识，还可以学习一些特定领域的知识，如计算机视觉、自然语言处理或增强学习等，以应用AI模型于具体的应用场景中。

学习AI模型开发是一个不断深入和不断学习的过程。建议从基础知识开始，逐步深入学习和实践，通过阅读书籍、参与在线课程、实践项目等方式提升自己的技能。

AI模型的训练

AI模型训练是一个迭代的过程，其目的是通过给定的输入数据（也称为训练数据）来调整模型的参数，使其能够对未知数据做出准确的预测或执行特定任务。

训练过程可以分为以下几个步骤：

1.数据收集和准备：首先，我们需要收集与目标任务相关的训练数据。这些数据可以是图像、文本、音频等形式。然后，我们对数据进行预处理和清洗，以确保数据质量和一致性。
2.模型选择和设计：根据任务的特点，我们选择适合的模型架构。不同的任务可能需要不同类型的模型，例如卷积神经网络（CNN）用于图像处理，循环神经网络（RNN）用于序列数据处理等。在选择模型后，我们设计模型的结构，包括层数、节点数量等。
3.参数初始化：模型中的参数是在训练过程中需要学习和调整的。在开始训练之前，我们需要对模型的参数进行初始化，可以使用随机初始化的方法。
4.前向传播：在训练过程中，我们将训练数据输入到模型中，通过前向传播的过程，模型根据当前的参数计算输出结果。
5.计算损失：通过比较模型的输出结果和训练数据中的真实标签，我们可以计算出模型的损失值。损失值表示模型预测的输出与真实标签之间的差异。
6.反向传播：在反向传播过程中，我们使用损失值来计算模型中每个参数对损失的贡献度，然后根据贡献度的方向调整参数的值。这个过程通过梯度下降算法来更新参数，使得模型的预测结果逐步接近真实标签。
7.参数更新：根据反向传播计算得到的梯度信息，我们更新模型中的参数值，使其朝着降低损失的方向移动。
8.重复迭代：重复进行前向传播、计算损失、反向传播和参数更新的过程，直到模型收敛或达到预设的停止条件（如训练轮数、损失阈值等）。

训练的目的是通过不断调整模型的参数，使得模型能够在未见过的数据上做出准确的预测或执行任务。通过大量的训练数据和迭代优化的过程，模型可以学习到输入数据的特征和模式，从而具备泛化能力，能够对新的数据进行准确的预测或执行任务。

设计AI模型

设计AI模型的过程可以分为以下几个关键步骤，以便程序员能够理解：

1. 确定任务：首先，明确你要解决的具体任务。这可能是图像分类、目标检测、文本生成等。确保清楚地定义任务的输入和期望输出。

2. 收集和准备数据：收集适用于任务的训练数据。这些数据应该涵盖各种情况和场景，以确保模型的泛化能力。对数据进行预处理，包括标准化、归一化、去噪等，以提高模型的训练效果。

3. 选择模型架构：根据任务的特点和数据的特征，选择适当的模型架构。常见的模型架构包括卷积神经网络（CNN）、循环神经网络（RNN）、变压器模型（Transformer）等。了解不同模型架构的原理和适用场景，选择最适合任务的模型。

4. 设计模型结构：在选择模型架构后，设计模型的具体结构。这包括确定模型的层数、每层的节点数量、激活函数的选择等。合理的模型结构应该能够有效地提取输入数据中的特征，并产生准确的输出。

5. 初始化参数：在训练模型之前，需要对模型的参数进行初始化。可以使用随机初始化的方法，为模型的权重和偏置等参数赋予初始值。

6. 定义损失函数：选择适当的损失函数来度量模型的预测结果与实际标签之间的差异。常见的损失函数包括均方误差（MSE）、交叉熵损失等。确保选择与任务和数据类型相匹配的损失函数。

7. 选择优化算法：为了训练模型并调整参数，需要选择适当的优化算法。常见的优化算法包括随机梯度下降（SGD）、Adam、RMSProp等。了解这些算法的原理和特点，选择最适合模型训练的优化算法。

8. 训练和评估模型：使用准备好的训练数据对模型进行训练。通过将输入数据传递给模型，计算模型的输出，并将其与实际标签进行比较，计算损失并更新模型参数。重复这个过程，直到模型收敛或达到预设的停止条件。在训练过程中，使用验证数据集对模型进行评估，并监控模型的性能。

9. 调优和改进：根据训练和评估的结果，根据需要对模型进行调优和改进。可以尝试调整模型的结构、超参数的选择，或者增加更多的训练数据等，以提高模型的性能和泛化能力。

10. 测试和部署：在训练完成后，使用独立的测试数据集对模型进行最终评估。确保模型在未见过的数据上表现良好。最后，将训练好的模型部署到实际应用中，用于实际的预测或任务执行。

通过以上步骤，你可以设计和训练一个AI模型，以解决特定的任务，并实现准确的预测或执行。根据不同的任务和应用领域，设计AI模型的具体细节和技术会有所不同。因此，不断学习和实践，积累经验是提高AI模型设计和训练的关键。

Transformers 和PyTorch的关系

Transformers和PyTorch是两个不同但相关的概念。

Transformers是一种模型架构，用于处理序列数据，特别是在自然语言处理（NLP）任务中表现出色。它最早由Vaswani等人于2017年提出，并在2018年的论文《Attention Is All You Need》中引入了注意力机制。Transformers模型的核心是自注意力机制，通过对输入序列中的不同位置进行注意力计算，从而捕捉全局上下文信息。

PyTorch是一个深度学习框架，提供了用于构建、训练和部署神经网络模型的工具和接口。它由Facebook的研究团队开发，并在深度学习社区中广泛应用。PyTorch提供了丰富的API和工具，使得开发者可以方便地定义神经网络结构、处理数据、进行模型训练和推理等。

在实践中，Transformers模型通常是使用PyTorch等深度学习框架进行实现和训练的。PyTorch提供了强大的张量操作和自动求导功能，使得实现和训练复杂的Transformers模型变得更加容易。此外，PyTorch还提供了许多与深度学习相关的库和工具，如PyTorch Lightning和TorchText，可以进一步简化模型开发和训练的过程。

因此，可以说Transformers是一种模型架构，而PyTorch是一个用于实现和训练Transformers模型的深度学习框架。PyTorch为开发者提供了构建和训练Transformers模型所需的工具和环境，使得使用Transformers模型变得更加便捷和高效。

AI人工智能产品缺陷检测

要使用Python进行产品缺陷检测，可以利用计算机视觉和机器学习技术。以下是一个基本的思路和步骤：

收集并准备缺陷和非缺陷的产品样本图像数据集。这些图像应包含不同类型和程度的产品缺陷，以及正常的产品图像作为对比。

使用图像处理技术，例如调整大小、灰度化、增强对比度等，对图像进行预处理，以便更好地提取特征。

提取图像特征。可以使用传统的计算机视觉方法，例如边缘检测、角点检测、纹理特征提取等，或使用深度学习模型进行特征提取。

图像的特征提取是计算机视觉中的一个重要任务，它可以帮助我们捕捉图像中的关键信息和表征。以下是一些常用的图像特征提取方式：

1.颜色特征：提取图像的颜色信息，例如直方图、颜色矩、颜色梯度等。

2.纹理特征：捕捉图像的纹理信息，例如灰度共生矩阵（GLCM）、局部二值模式（LBP）、Gabor滤波器等。

3.形状特征：描述图像中的形状和边界信息，例如边缘检测、轮廓特征、形状描述子（如Hu矩、Zernike矩）等。

4.角点特征：检测图像中的关键点和角点，例如Harris角点检测、Shi-Tomasi角点检测、FAST角点检测等。

5.尺度不变特征变换（SIFT）：通过检测图像中的局部特征点，并计算其描述子，从而实现对尺度、旋转、光照变化等的不变性。

6.领域知识特征：利用特定领域的先验知识，设计和提取与特定任务相关的特征，例如医学图像中的肿瘤形态学特征。

7.深度学习特征：使用深度卷积神经网络（CNN）等深度学习模型，通过从大规模数据集中进行端到端训练，自动学习图像的高级特征表示。

以上仅列举了一些常见的图像特征提取方式，实际上还有很多其他方法和技术可供选择。特征的选择应该根据具体任务和数据集的特点来确定，有时也可以结合多种特征进行综合表示。此外，特征提取往往是图像处理和计算机视觉任务的前置步骤，后续的任务可以基于提取的特征进行分类、检测、定位等操作。

构建分类模型。使用准备好的样本数据集，训练一个分类模型，例如卷积神经网络（CNN）或支持向量机（SVM），来区分缺陷和非缺陷的产品。

在Python中，可以使用深度学习框架如TensorFlow、Keras、PyTorch等来构建和训练分类模型。这些框架提供了丰富的工具和API，以简化模型的构建、训练和评估过程。

对新的产品图像进行预测。使用训练好的模型，对新的产品图像进行预测，判断其是否存在缺陷。

根据预测结果进行处理。根据预测结果，可以自动化地处理有缺陷的产品，例如标记、分类、拒绝等。

定期评估和优化模型性能。对模型进行评估，根据反馈信息进行优化和改进，以提高缺陷检测的准确性和鲁棒性。

需要注意的是，以上步骤仅提供了一个基本的思路。实际应用中，可能需要根据具体情况进行调整和改进。例如，如果缺陷种类较多或样本不平衡，可能需要采用更复杂的模型或进行数据增强等处理。此外，还可以结合其他技术，如目标检测、图像分割等，来更精确地定位和识别产品缺陷。

综上所述，产品缺陷检测是一个复杂的任务，需要综合运用计算机视觉和机器学习技术。在实际应用中，可能需要进行多轮迭代和调优，以获得最佳的缺陷检测效果。

PyTorch深度学习快速入门教程

点击查看原视频

点击进入PyTorch主页

B站强推！2023公认最通俗易懂的【PyTorch】教程

点击查看原视频

人工智能与机器人|常用的数据集格式

点击查看原文

AI模型的格式有哪些文件后缀分别是啥及各种格式模型的使用方法

AI模型可以有多种不同的文件格式，每种格式都有自己的文件后缀和使用方法。以下是一些常见的AI模型格式及其文件后缀和使用方法：

TensorFlow模型：

文件后缀：.pb（Protocol Buffer格式）、.h5（HDF5格式）

使用方法：使用TensorFlow框架的API加载和使用模型。可以使用tf.saved_model.loader.load()函数加载.pb文件，使用tf.keras.models.load_model()函数加载.h5文件。

PyTorch模型：

文件后缀：.pt、.pth

使用方法：使用PyTorch框架的API加载和使用模型。可以使用torch.load()函数加载.pt或.pth文件。

pytorch使用pt模型

步骤1：导入必要的库和模块

在这一步中，我们需要导入PyTorch和其他必要的库和模块。通常，我们需要导入以下库和模块：

import torch

import torchvision

步骤2：加载.pt模型文件

在这一步中，我们将加载.pt模型文件。我们可以使用torch.load函数来加载.pt模型文件，并将其保存为一个变量。

model = torch.load('model.pt')

这里，model.pt表示.pt模型文件的路径。请确保.pt模型文件位于当前工作目录中，或者提供正确的文件路径。

步骤3：使用模型进行推理或训练

在这一步中，我们可以使用加载的模型进行推理或训练。根据具体的任务，我们可能需要做一些预处理或后处理的操作。

output = model(input)

这里，input表示输入数据。请根据具体的任务和模型的要求提供正确的输入。

步骤4：保存模型（可选）

在这一步中，我们可以选择将训练好的模型保存为.pt文件，以备将来使用。

torch.save(model, 'model.pt')

这里，model表示要保存的模型对象，model.pt表示保存的.pt文件的路径。请确保提供正确的文件路径。

一、做法

1.*.pt文件

.pt文件保存的是模型的全部，在加载时可以直接赋值给新变量model = torch.load("filename.pt")。

具体操作:

（1）. 模型的保存

torch.save(model,"Path/文件名.pt")

这里的Path为你想将模型保存的位置，写完Path后加一个"/"表示进入目录内部，最后给出文件名.pt.

（2）. 模型的加载

model = torch.load("文件名.pt")

注意：torch.load()的参数使用字符串参数。

2. .pth文件

.pth保存的是模型参数，通过字符字典进行保存，在加载该类文件时应该先实例化一个具体的模型，然后对新建立的空模型，进行参数赋予。

具体操作:

（1）. 模型的保存

torch.save(model.state_dict(), PATH)

（2）. 模型的加载

model = nn.Module() # 这里要先实例化模型

model.load_state_dict(torch.load("xxx.pth"))

二、操作实例

这里先定义一个模型作为例子

# Define model

class TheModelClass(nn.Module):

# 类的初始化

def __init__(self):

# 继承父类 nn.Module 的属性和方法

super(TheModelClass, self).__init__()

# Inputs_channel, Outputs_channel, kernel_size

self.conv1 = nn.Conv2d(3, 6, 5)

# 最大池化层，池化核的大小

self.pool = nn.MaxPool2d(2, 2)

# 卷积层，池化层，卷积层

self.conv2 = nn.Conv2d(6, 16, 5)

# 最后接一个线性全连接层

self.fc1 = nn.Linear(16 * 5 * 5, 120)

self.fc2 = nn.Linear(120, 84)

self.fc3 = nn.Linear(84, 10)

def forward(self, x):

# 卷积作用后，使用relu进行非线性化，最后使用池化操作进行特征个数，参数量的降低

x = self.pool(F.relu(self.conv1(x)))

x = self.pool(F.relu(self.conv2(x)))

x = x.view(-1, 16 * 5 * 5)

x = F.relu(self.fc1(x))

x = F.relu(self.fc2(x))

x = self.fc3(x)

return x

# Initialize model

model = TheModelClass()

# Initialize optimizer

optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# Print model's state_dict

print("Model's state_dict:")

for param_tensor in model.state_dict():

print(param_tensor, "\t", model.state_dict()[param_tensor].size())

# Print optimizer's state_dict

print("Optimizer's state_dict:")

for var_name in optimizer.state_dict():

print(var_name, "\t", optimizer.state_dict()[var_name])

2. 现在开始进行模型的保存与加载

PATH = "E:/深度学习/model"

# ######################### 第一种模型保存和加载方式

torch.save(model.state_dict(), PATH+"/TheModuleClass.pth")

model = TheModelClass()

model.load_state_dict(torch.load("E:/深度学习/model/TheModuleClass.pth"))

for param_tensor in model.state_dict():

print(f"{param_tensor}<<<{model.state_dict()[param_tensor].size()}")

print(model)

# ####### 输出结果

'''

conv1.weight<<<torch.Size([6, 3, 5, 5])

conv1.bias<<<torch.Size([6])

conv2.weight<<<torch.Size([16, 6, 5, 5])

conv2.bias<<<torch.Size([16])

fc1.weight<<<torch.Size([120, 400])

fc1.bias<<<torch.Size([120])

fc2.weight<<<torch.Size([84, 120])

fc2.bias<<<torch.Size([84])

fc3.weight<<<torch.Size([10, 84])

fc3.bias<<<torch.Size([10])

TheModelClass(

(conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))

(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)

(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))

(fc1): Linear(in_features=400, out_features=120, bias=True)

(fc2): Linear(in_features=120, out_features=84, bias=True)

(fc3): Linear(in_features=84, out_features=10, bias=True)

)

'''

# ########################### 第二种模型保存和加载方式

torch.save(model, PATH + "/the_module_class.pt")

model = torch.load(PATH + "/the_module_class.pt")

for param_tensor in model.state_dict():

print(f"{param_tensor} <<< {model.state_dict()[param_tensor].size()}")

print(model)

# ####### 输出结果

'''

conv1.weight<<<torch.Size([6, 3, 5, 5])

conv1.bias<<<torch.Size([6])

conv2.weight<<<torch.Size([16, 6, 5, 5])

conv2.bias<<<torch.Size([16])

fc1.weight<<<torch.Size([120, 400])

fc1.bias<<<torch.Size([120])

fc2.weight<<<torch.Size([84, 120])

fc2.bias<<<torch.Size([84])

fc3.weight<<<torch.Size([10, 84])

fc3.bias<<<torch.Size([10])

TheModelClass(

(conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))

(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)

(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))

(fc1): Linear(in_features=400, out_features=120, bias=True)

(fc2): Linear(in_features=120, out_features=84, bias=True)

(fc3): Linear(in_features=84, out_features=10, bias=True)

)

'''

总结

这里推荐使用第二种方法，因为保存和加载文件简单，而且生成的二进制文件区分程度高。

torch.save() 保存模型的参数，为以后模型推理核模型恢复提供了更加方便更加灵活的方法。

一定要在模型评估时，关闭批量规范化和丢弃法, 仅仅在模型训练时有用，模型推理时一定要关闭(所谓模型推理，指是使用模型进行的实际应用)

加载.pth 要先实例化，再进行参数的承接。

ONNX模型：

文件后缀：.onnx

使用方法：使用ONNX框架或支持ONNX的其他框架加载和使用模型。可以使用onnxruntime库加载和执行ONNX模型。

Keras模型：

文件后缀：.h5

使用方法：使用Keras框架的API加载和使用模型。可以使用keras.models.load_model()函数加载.h5文件。

Caffe模型：

文件后缀：.caffemodel、.prototxt

使用方法：使用Caffe框架的API加载和使用模型。可以使用caffe.Net()函数加载.caffemodel和.prototxt文件。

在大型深度学习模型的上下文中，.safetensors、.bin 和 .pth ckpt 文件的用途和区别如下：

.safetensors 文件：

这是由 Hugging Face 推出的一种新型安全模型存储格式，特别关注模型安全性、隐私保护和快速加载。

它仅包含模型的权重参数，而不包括执行代码，这样可以减少模型文件大小，提高加载速度。

加载方式：使用 Hugging Face 提供的相关API来加载 .safetensors 文件，例如 safetensors.torch.load_file() 函数。

ckpt文件：

ckpt 文件是 PyTorch Lightning 框架采用的模型存储格式，它不仅包含了模型参数，还包括优化器状态以及可能的训练元数据信息，使得用户可以无缝地恢复训练或执行推理。

.bin 文件：

通常是一种通用的二进制格式文件，它可以用来存储任意类型的数据。

在机器学习领域，.bin 文件有时用于存储模型权重或其他二进制数据，但并不特指PyTorch的官方标准格式。

对于PyTorch而言，如果用户自己选择将模型权重以二进制格式保存，可能会使用 .bin 扩展名，加载时需要自定义逻辑读取和应用这些权重到模型结构中。

.pth 文件：

是 PyTorch 中用于保存模型状态的标准格式。

主要用于保存模型的 state_dict，包含了模型的所有可学习参数，或者整个模型（包括结构和参数）。

加载方式：使用 PyTorch 的 torch.load() 函数直接加载 .pth 文件，并通过调用 model.load_state_dict() 将加载的字典应用于模型实例。

总结起来：

.safetensors 侧重于安全性和效率，适合于那些希望快速部署且对安全有较高要求的场景，尤其在Hugging Face生态中。

.ckpt 文件是 PyTorch Lightning 框架采用的模型存储格式，它不仅包含了模型参数，还包括优化器状态以及可能的训练元数据信息，使得用户可以无缝地恢复训练或执行推理。

.bin 文件不是标准化的模型保存格式，但在某些情况下可用于存储原始二进制权重数据，加载时需额外处理。

.pth 是PyTorch的标准模型保存格式，方便模型的持久化和复用，支持完整模型结构和参数的保存与恢复。

加载以及保存

- 加载.safetensors文件：

# 用SDXL举例

import torch

from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, EulerDiscreteScheduler

from huggingface_hub import hf_hub_download

from safetensors.torch import load_file

base = "stabilityai/stable-diffusion-xl-base-1.0"

repo = "ByteDance/SDXL-Lightning"

ckpt = "/home/bino/svul/models/sdxl/sdxl_lightning_2step_unet.safetensors" # Use the correct ckpt for your step setting!

# Load model.

unet = UNet2DConditionModel.from_config(base, subfolder="unet").to("cuda", torch.float16)

unet.load_state_dict(load_file(ckpt, device="cuda"))

# unet.load_state_dict(load_file(hf_hub_download(repo, ckpt), device="cuda"))

pipe = StableDiffusionXLPipeline.from_pretrained(base, unet=unet, torch_dtype=torch.float16, variant="fp16").to("cuda")

# Ensure sampler uses "trailing" timesteps.

pipe.scheduler = EulerDiscreteScheduler.from_config(pipe.scheduler.config, timestep_spacing="trailing")

# Ensure using the same inference steps as the loaded model and CFG set to 0.

pipe("A girl smiling", num_inference_steps=4, guidance_scale=0).images[0].save("output.png")

- 保存/加载.pth文件：

# 保存模型状态字典

torch.save(model.state_dict(), "model.pth")

# 加载模型状态字典到已有模型结构中

model = TheModelClass(*args, **kwargs)

model.load_state_dict(torch.load("model.pth"))

# 或者保存整个模型，包括结构

torch.save(model, "model.pth")

# 加载整个模型

model = torch.load("model.pth", map_location=device)

- 保存/加载.ckpt文件：

import pytorch_lightning as pl

# 定义一个 PyTorch Lightning 训练模块

class MyLightningModel(pl.LightningModule):

def __init__(self):

super().__init__()

self.linear_layer = nn.Linear(10, 1)

self.loss_function = nn.MSELoss()

def forward(self, inputs):

return self.linear_layer(inputs)

def training_step(self, batch, batch_idx):

features, targets = batch

predictions = self(features)

loss = self.loss_function(predictions, targets)

self.log('train_loss', loss)

return loss

# 初始化 PyTorch Lightning 模型

lightning_model = MyLightningModel()

# 配置 ModelCheckpoint 回调以定期保存最佳模型至 .ckpt 文件

checkpoint_callback = pl.callbacks.ModelCheckpoint(

monitor='val_loss',

filename='best-model-{epoch:02d}-{val_loss:.2f}',

save_top_k=3,

mode='min'

)

# 创建训练器并启动模型训练

trainer = pl.Trainer(

callbacks=[checkpoint_callback],

max_epochs=10

)

trainer.fit(lightning_model)

# 从 .ckpt 文件加载最优模型权重

best_model = MyLightningModel.load_from_checkpoint(checkpoint_path='best-model.ckpt')

# 使用加载的 .ckpt 文件中的模型进行预测

sample_input = torch.randn(1, 10)

predicted_output = best_model(sample_input)

print(predicted_output)

在此示例中，我们首先定义了一个 PyTorch Lightning 模块，该模块集成了模型训练的逻辑。然后，我们配置了 ModelCheckpoint 回调函数，在训练过程中按照验证损失自动保存最佳模型至 .ckpt 文件。接着，我们展示了如何加载 .ckpt 文件中的最优模型权重，并利用加载后的模型对随机输入数据进行预测，同样输出预测结果。值得注意的是，由于 .ckpt 文件完整记录了训练状态，它在实际应用中常被用于模型微调和进一步训练。

- 处理.bin文件：

如果.bin文件是纯二进制权重文件，加载时需要知道模型结构并且手动将权重加载到对应的层中，例如：

# 假设已经从.bin文件中读取到了模型权重数据

weights_data = load_binary_weights("weights.bin")

# 手动初始化模型并加载权重

model = TheModelClass(*args, **kwargs)

for name, param in model.named_parameters():

if name in weights_mapping: # 需要预先知道权重映射关系

param.data.copy_(weights_data[weights_mapping[name]])

模型之间的互相转换

pytorch-lightning 和 pytorch

由于 PyTorch Lightning 模型本身就是 PyTorch 模型，因此不存在严格意义上的转换过程。你可以直接通过 LightningModule 中定义的神经网络层来进行保存和加载，就像普通的 PyTorch 模型一样：

# 假设 model 是一个 PyTorch Lightning 模型实例

model = MyLightningModel()

# 保存模型权重

torch.save(model.state_dict(), 'lightning_model.pth')

# 加载到一个新的 PyTorch 模型实例

new_model = MyLightningModel()

new_model.load_state_dict(torch.load('lightning_model.pth'))

# 或者加载到一个普通的 PyTorch Module 实例（假设结构一致）

plain_pytorch_model = MyPlainPytorchModel()

plain_pytorch_model.load_state_dict(torch.load('lightning_model.pth'))

ckpt和safetensors

转换后的模型在stable-diffussion-webui中使用过没有问题，不知道有没有错误，或者没转换成功

import torch

import os

import safetensors

from typing import Dict, List, Optional, Set, Tuple

from safetensors.torch import _find_shared_tensors, _is_complete, load_file, save_file

def ckpt2safetensors():

loaded = torch.load('v1-5-pruned-emaonly.ckpt')

if "state_dict" in loaded:

loaded = loaded["state_dict"]

safetensors.torch.save_file(loaded, 'v1-5-pruned-emaonly.safetensors')

def st2ckpt():

# 加载 .safetensors 文件

data = safetensors.torch.load_file('v1-5-pruned-emaonly.safetensors.bk')

data["state_dict"] = data

# 将数据保存为 .ckpt 文件

torch.save(data, os.path.splitext('v1-5-pruned-emaonly.safetensors')[0] + '.ckpt')

何为JSONL 文件

JSONL (JSON Lines) 是一种文本文件格式，其中每一行都是一个独立的 JSON 对象。它与传统的 JSON 文件不同，传统的 JSON 文件将所有数据存储在一个单一的对象或数组中。

JSONL 的优点:

易于解析: 每行都是独立的 JSON 对象，解析器可以逐行处理文件，而无需将整个文件加载到内存中。

流式处理: JSONL 文件非常适合处理流数据，因为数据可以逐行写入和读取。

易于追加: 可以轻松地将新的 JSON 对象追加到现有 JSONL 文件的末尾。

JSONL 的缺点:

可读性较差: 与格式化的 JSON 文件相比，JSONL 文件的可读性较差。

不适合嵌套数据: JSONL 文件不太适合存储高度嵌套的数据结构。

JSONL 文件样本

以下是一个包含用户信息的 JSONL 文件样本：

{"id": 1, "name": "John Doe", "age": 30, "city": "New York"}

{"id": 2, "name": "Jane Doe", "age": 25, "city": "Los Angeles"}

{"id": 3, "name": "Peter Pan", "age": 20, "city": "London"}

说明:

文件中的每一行代表一个用户。

每一行都是一个有效的 JSON 对象，包含用户的 ID、姓名、年龄和城市信息。

上一篇：嵌入式AI开发的那些事

下一篇：AI硬件

您现在的位置是：网站首页> AI人工智能

AI人工智能的基础知识

相关文章