高通 AI Stack 稳定扩散Demo指南（3）

最新推荐文章于 2024-03-28 00:00:41 发布
最新推荐文章于 2024-03-28 00:00:41 发布
阅读量577 收藏 8
点赞数 5
分类专栏： AI Qualcomm 笔记 文章标签： 人工智能 Qualcomm ai
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38498942/article/details/136376607
版权
笔记 同时被 3 个专栏收录
364 篇文章 28 订阅
订阅专栏
Qualcomm
150 篇文章 7 订阅
订阅专栏
AI
50 篇文章 0 订阅
订阅专栏

高通 AI Stack 稳定扩散Demo指南（3）

1.2.2 Linux 上的 Qualcomm AI Engine 直接模型准备

Qualcomm AI Engine Direct SDK 允许客户在 HTP 硬件上运行机器学习模型。以下步骤描述了如何在具有 HTP 功能的 Linux 平台上准备和执行稳定扩散模型。

本文档交替使用术语 Qualcomm 神经网络 (QNN) 和 Qualcomm AI Engine Direct SDK。

先决条件

  1. Qualcomm AI Engine Direct SDK（支持 Ubuntu Linux）
  2. Ubuntu 20.04 安装以及 QNN 工具所需的软件包
  3. Android 平台工具版本 31 或更高版本
  4. 该笔记本可以使用 Anaconda（使用提供的environment.yaml）或虚拟环境（venv）执行
  5. 稳定的扩散.onnx文件及其相应的 AIMET 编码（通过 AIMET 工作流程生成）

此工作流程假设您已按照 AIMET 稳定扩散工作流程生成了稳定扩散模型工件：

  • 稳定扩散文本编码器模型及其 AIMET 编码
  • 稳定扩散 U-Net 模型及其 AIMET 编码
  • 稳定扩散变分自动编码器 (VAE) 模型及其 AIMET 编码
  • fp32.npyfile - 保存为 Python pickle 的 numpy 对象数组，其中包含模型转换步骤所需的数据。

测试环境
Linux x86 电脑

  • 发行商 ID：Ubuntu
  • 说明：Ubuntu 20.04.5 LTS
  • 发布时间：20.04
  • 平台：x86_64 AMD

工作流程
这三个模型和编码通过 Qualcomm AI Engine Direct SDK 中提供的不同可执行 QNN 实用程序独立处理。

要准备用于推理的稳定扩散模型，QNN 可执行实用程序需要 Ubuntu 20.04 环境

  • 将文件转换.onnx为等效的 QNN 表示形式A16W8（16 位激活和 8 位权重）
  • 生成 QNN 模型库
  • 为 QNN HTP 后端生成 QNN 上下文二进制文件

准备好用于推理的稳定扩散模型后，下一步是在 Snapdragon Android 设备上执行 QNN 上下文二进制文件以进行推理。请参阅 qnn_model_execution_on_android.ipynb。

在这里插入图片描述
可以使用 Anaconda 或 Python 虚拟环境 (venv) 设置 Python 环境。

注意：在执行笔记本之前，必须执行以下两个设置 Python 环境的步骤之一。

如果您已经启动了 jupyer 笔记本，请先配置 Python 环境，然后再继续。配置Python环境后，重新启动笔记本服务器并选择正确的内核。

设置
在 Ubuntu 20.04 终端中设置 Anaconda

  1. 从以下位置安装 Anaconda：https://repo.anaconda.com/archive/Anaconda3-2023.03-1-Linux-x86_64.sh。

  2. 使用以下命令执行安装脚本。

    chmod a+x Anaconda3-2023.03-1-Linux-x86_64.sh && bash Anaconda3-2023.03-1-Linux-x86_64.sh

  3. 在 Ubuntu 20.04 终端中使用以下命令配置 Anaconda 环境。

    conda create --name stable_diffusion_env python=3.8

    conda activate stable_diffusion_env

    conda install ipykernel

    ipython kernel install --user --name=stable_diffusion_env

在 Ubuntu 20.04 终端中设置 venv（非 Anaconda）
以下步骤安装在 Ubuntu 20.04 环境（Ubuntu 终端窗口）中使用 QNN 工具所需的软件包。

  1. 更新包索引文件。

    sudo apt-get update

  2. 安装Python3.8和必要的包。

    默认情况下，Ubuntu 20.04 应该附带 Python 3.8，您无需再次安装。但是要重新安装它，请运行以下命令。

    sudo bash -c ‘apt-get update && apt-get install software-properties-common && add-apt-repository ppa:deadsnakes/ppa && apt-get install python3.8 python3.8-distutils libpython3.8’

  3. 安装 python3-pip。

    sudo apt-get install python3-pip

  4. 安装python3虚拟环境支持。

    sudo apt install python3-virtualenv

  5. 通过执行以下命令创建并激活Python 3.8虚拟环境。

     virtualenv -p /usr/bin/python3.8 venv_stable_diffusion
 source venv_stable_diffusion/bin/activate

安装所需的Python包

pip install --quiet -r requirements.txt

设置 Qualcomm AI Engine Direct SDK

以下步骤配置 Qualcomm AI Engine Direct SDK，以便在设备上运行 Stable Diffusion。在 Ubuntu 20.04 终端上执行以下命令。

注意：这些步骤需要 sudo 或 root 权限。

  1. 在Ubuntu中设置Python和pip后，检查QNN工具依赖关系；看/docs/QNN/general/setup.html 了解有关 QNN 设置和 ML 框架依赖项的更多信息。
  2. 将QNN_SDK_ROOT环境变量设置为 Qualcomm AI Engine 目录的位置。对于Linux，export QNN_SDK_ROOT=“./assets/qnn_assets/unzipped_qnn_sdk_linux/”
  3. 检查并安装 Linux 依赖项。
 source $QNN_SDK_ROOT/bin/check-linux-dependency.sh
 sudo apt-get install -y libtinfo5

为 Qualcomm AI Engine 设置 Python 依赖项

import os
#Check and install Python dependencies
QNN_SDK_ROOT=os.getcwd() + "/assets/qnn_assets/unzipped_qnn_sdk_linux/"
!python $QNN_SDK_ROOT/bin/check-python-dependency

准备用于推理的稳定扩散模型
以下部分使用 Qualcomm AI Engine Direct SDK 为目标推理准备稳定的扩散模型。

# Set up environment variable to reference STABLE_DIFFUSION_MODELS
STABLE_DIFFUSION_MODELS = os.getcwd() + "/assets/stable_diffusion/"

将模型从 ONNX 表示转换为 QNN 表示

Qualcomm AI Engine Direct SDKqnn-onnx-conerter工具可将模型从 ONNX 表示精确转换为等效的 QNN 表示A16W8。从 AIMET 工作流程生成的编码文件通过选项提供作为此步骤的输入–quantization_overrides model.encodings。

此步骤生成一个.cpp文件，该文件将模型表示为一系列 QNN API 调用，以及一个.bin包含静态数据的文件，静态数据通常是模型权重并由.cpp文件引用。

对于所有三个模型，此步骤必须独立完成。

生成模型输入列表/数据

inputs_pickle_path=STABLE_DIFFUSION_MODELS + '/fp32.npy'
!python3 generate_inputs.py --pickle_path $inputs_pickle_path --working_dir $STABLE_DIFFUSION_MODELS

为 Qualcomm AI Direct SDK 工具设置环境变量

env = os.environ.copy()
env["QNN_SDK_ROOT"] = QNN_SDK_ROOT
env["PYTHONPATH"] = QNN_SDK_ROOT + "/benchmarks/QNN/:" + QNN_SDK_ROOT + "/lib/python"
env["PATH"] = QNN_SDK_ROOT + "/bin/x86_64-linux-clang:" + env["PATH"]
env["LD_LIBRARY_PATH"] = QNN_SDK_ROOT + "/lib/x86_64-linux-clang"
env["HEXAGON_TOOLS_DIR"] = QNN_SDK_ROOT + "/bin/x86_64-linux-clang"

转换文本编码器

mport subprocess

!mkdir $STABLE_DIFFUSION_MODELS/converted_text_encoder
proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-onnx-converter",
                  "-o", STABLE_DIFFUSION_MODELS + "/converted_text_encoder/qnn_model.cpp",
                   "-i",STABLE_DIFFUSION_MODELS + "/text_encoder_onnx/text_encoder.onnx",
                   "--input_list", STABLE_DIFFUSION_MODELS + "/text_encoder_onnx/text_encoder_input_list.txt",
                   "--act_bw", "16",
                   "--bias_bw", "32",
                   "--quantization_overrides", STABLE_DIFFUSION_MODELS + "/text_encoder_onnx/text_encoder.encodings"
                 ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

# Rename the model files to make them unique and helpful for subsequent stages
!mv $STABLE_DIFFUSION_MODELS/converted_text_encoder/qnn_model.cpp $STABLE_DIFFUSION_MODELS/converted_text_encoder/text_encoder.cpp
!mv $STABLE_DIFFUSION_MODELS/converted_text_encoder/qnn_model.bin $STABLE_DIFFUSION_MODELS/converted_text_encoder/text_encoder.bin
!mv $STABLE_DIFFUSION_MODELS/converted_text_encoder/qnn_model_net.json $STABLE_DIFFUSION_MODELS/converted_text_encoder/text_encoder_net.json

转换U-Net

预计执行时间：~ 1.5 小时

!mkdir $STABLE_DIFFUSION_MODELS/converted_unet

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-onnx-converter",
                  "-o", STABLE_DIFFUSION_MODELS + "/converted_unet/qnn_model.cpp",
                   "-i",STABLE_DIFFUSION_MODELS + "/unet_onnx/unet.onnx",
                   "--input_list", STABLE_DIFFUSION_MODELS + "/unet_onnx/unet_input_list.txt",
                   "--act_bw", "16",
                   "--bias_bw", "32",
                   "--quantization_overrides", STABLE_DIFFUSION_MODELS + "/unet_onnx/unet.encodings",
                   "-l", "input_3", "NONTRIVIAL"
                 ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

# Rename the model files to make them unique and helpful for subsequent stages
!mv $STABLE_DIFFUSION_MODELS/converted_unet/qnn_model.cpp $STABLE_DIFFUSION_MODELS/converted_unet/unet.cpp
!mv $STABLE_DIFFUSION_MODELS/converted_unet/qnn_model.bin $STABLE_DIFFUSION_MODELS/converted_unet/unet.bin
!mv $STABLE_DIFFUSION_MODELS/converted_unet/qnn_model_net.json $STABLE_DIFFUSION_MODELS/converted_unet/unet_net.json

转换VAE解码器

预计执行时间：~25 分钟

!mkdir $STABLE_DIFFUSION_MODELS/converted_vae_decoder

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-onnx-converter",
                  "-o", STABLE_DIFFUSION_MODELS + "/converted_vae_decoder/qnn_model.cpp",
                   "-i",STABLE_DIFFUSION_MODELS + "/vae_decoder_onnx/vae_decoder.onnx",
                   "--input_list", STABLE_DIFFUSION_MODELS + "/vae_decoder_onnx/vae_decoder_input_list.txt",
                   "--act_bw", "16",
                   "--bias_bw", "32",
                   "--quantization_overrides", STABLE_DIFFUSION_MODELS + "/vae_decoder_onnx/vae_decoder.encodings"
                 ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())


# Rename for uniqueness
!mv $STABLE_DIFFUSION_MODELS/converted_vae_decoder/qnn_model.cpp $STABLE_DIFFUSION_MODELS/converted_vae_decoder/vae_decoder.cpp
!mv $STABLE_DIFFUSION_MODELS/converted_vae_decoder/qnn_model.bin $STABLE_DIFFUSION_MODELS/converted_vae_decoder/vae_decoder.bin
!mv $STABLE_DIFFUSION_MODELS/converted_vae_decoder/qnn_model_net.json $STABLE_DIFFUSION_MODELS/converted_vae_decoder/vae_decoder_net.json

QNN模型库

Qualcomm AI Engine Direct SDKqnn-model-lib-generator将模型.cpp和.bin文件编译为特定目标的共享对象库。此示例为 x86_64-linux 目标生成共享对象库。

此阶段的输入是上一步中生成的model.cpp和文件。model.bin

生成文本编码器模型库

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-model-lib-generator",
                        "-c", STABLE_DIFFUSION_MODELS + "/converted_text_encoder/text_encoder.cpp",
                        "-b", STABLE_DIFFUSION_MODELS + "/converted_text_encoder/text_encoder.bin",
                        "-t", "x86_64-linux-clang",
                        "-o", STABLE_DIFFUSION_MODELS + "/converted_text_encoder"
                        ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

生成U-Net模型库

预计执行时间：~25 分钟

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-model-lib-generator",
                        "-c", STABLE_DIFFUSION_MODELS + "/converted_unet/unet.cpp",
                        "-b", STABLE_DIFFUSION_MODELS + "/converted_unet/unet.bin",
                        "-t", "x86_64-linux-clang",
                        "-o", STABLE_DIFFUSION_MODELS + "/converted_unet"
                        ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

生成VAE解码器模型库

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-model-lib-generator",
                        "-c", STABLE_DIFFUSION_MODELS + "/converted_vae_decoder/vae_decoder.cpp",
                        "-b", STABLE_DIFFUSION_MODELS + "/converted_vae_decoder/vae_decoder.bin",
                        "-t", "x86_64-linux-clang",
                        "-o", STABLE_DIFFUSION_MODELS + "/converted_vae_decoder"
                        ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

QNN HTP 上下文二进制文件

Qualcomm AI Engine Direct SDKqnn-context-binary-generator工具创建适用于 QNN HTP 后端的 QNN 上下文二进制文件。该二进制文件可以部署在运行 Android 的 Snapdragon Gen2 设备上运行。此步骤需要上一步中的模型共享对象库以及libQnnHtp.soQualcomm AI Engine Direct SDK 中提供的库。

通过传递为 QNN HTP 后端libQnnHtpBackendExtensions.so实现扩展的库，提供与 QNN HTP 后端相关的其他选项。该库可在 Qualcomm AI Engine Direct SDK 中找到。库和配置.json以如下所示的格式提供。有关后端扩展和配置参数的文档可在 Qualcomm AI Engine Direct SDK 文档中找到。

# HTP backend extensions config file (htp_backend_extensions.json) example
htp_backend_extensions_data = '''
{
    "backend_extensions": {
        "shared_library_path": "libQnnHtpNetRunExtensions.so",
        "config_file_path": "/tmp/htp_config.json"
    }
}
'''

# HTP backend config file (htp_config.json) example
htp_backend_config_data = '''
{
    "graphs": {
        "vtcm_mb":8,
        "graph_names":["qnn_model"]
    },
    "devices": [
        {
            "soc_id": 57,
            "dsp_arch": "v73",
            "cores":[{
                "core_id": 0,
                "perf_profile": "burst",
                "rpc_control_latency":100
            }]
        }
    ]
}
'''
#write the config files to a temporary location
with open('/tmp/htp_backend_extensions.json','w') as f:
    f.write(htp_backend_extensions_data)
with open('/tmp/htp_config.json','w') as f:
    f.write(htp_backend_config_data)

# Create a path under the models directory for serialized binaries
!mkdir $STABLE_DIFFUSION_MODELS/serialized_binaries

为文本编码器生成 QNN 上下文二进制文件

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-context-binary-generator",
                             "--model", STABLE_DIFFUSION_MODELS + "/converted_text_encoder/x86_64-linux-clang/libtext_encoder.so",
                             "--backend", "libQnnHtp.so",
                             "--output_dir",  STABLE_DIFFUSION_MODELS + "/serialized_binaries",
                             "--binary_file", "text_encoder.serialized",
                             "--config_file", "/tmp/htp_backend_extensions.json",
                             "--log_level", "verbose"
                        ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

为 U-Net 生成 QNN 上下文二进制文件

预计执行时间：~2 分钟

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-context-binary-generator",
                             "--model", STABLE_DIFFUSION_MODELS + "/converted_unet/x86_64-linux-clang/libunet.so",
                             "--backend", "libQnnHtp.so",
                             "--output_dir",  STABLE_DIFFUSION_MODELS + "/serialized_binaries",
                             "--binary_file", "unet.serialized",
                             "--config_file", "/tmp/htp_backend_extensions.json"
                        ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

为 VAE 解码器生成 QNN 上下文二进制文件

预计执行时间：~1.5 分钟

proc = subprocess.Popen([QNN_SDK_ROOT + "/bin/x86_64-linux-clang/qnn-context-binary-generator",
                             "--model", STABLE_DIFFUSION_MODELS + "/converted_vae_decoder/x86_64-linux-clang/libvae_decoder.so",
                             "--backend", "libQnnHtp.so",
                             "--output_dir",  STABLE_DIFFUSION_MODELS + "/serialized_binaries",
                             "--binary_file", "vae_decoder.serialized",
                             "--config_file", "/tmp/htp_backend_extensions.json"
                        ],stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
output, error = proc.communicate()
print(output.decode(),error.decode())

完成这些准备用于推理的稳定扩散模型的步骤后，这三个模型的 QNN 上下文二进制文件可在$STABLE_DIFFUSION_MODELS/serialized_binaries/

下一步是使用 Qualcomm AI Engine Direct SDK 中提供的可执行实用程序在 Snapdragon Gen2 Android 设备上执行准备好的模型（现在表示为序列化上下文二进制文件）。

weixin_38498942
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
webstack-hugo:Hugo版 WebStack 主题 Demo
05-31
Hugo版 WebStack 主题 本项目是基于纯静态的网址导航网站 制作的主题，主题安装后，将exampleSite目录下的文件复制到hugo站点根目录，网址信息可通过data目录下webstack.yml修改。 这是一个开源的公益项目，你可以拿来制作自己的网址导航，也可以做与导航无关的网站。
华为云Stack 6.5.0 API开发指南
08-26
华为云Stack解决方案API接口统一通过API网关对外提供服务，用户需要基于华为云Stack做应用/云平台开发时，可以直接调用API网关上开放的API组件API。华为云Stack解决方案API分认证、运维、运营、IaaS、PaaS、BC&DR（灾备）、HiCloud等几部分。
Qualcomm AI Engine Direct SDK（QNN）的使用介绍
最新发布
u013250861的博客
03-28 217
Qualcomm AI Engine Direct SDK，高通新的AI模型推理框架，又名QNN，为AI开发提供统一API的底层框架。通过这个SDK，可以在高通的 CPU/GPU和HTP上对AI模型进行性能加速。2.Qualcomm AI Engine Direct SDK的公开英文文档。1.Qualcomm AI Engine Direct SDK的下载和安装。
一些不错的文档网址--笔记【原创】
weixin_34234823的博客
06-30 2万+
一些不错的内核文档网址 1. 轻松认识 Linux Kernel 转自：http://www.bricktou.com/default_cn.html  git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git git reset v4.0 -hard http://www.infradead...
eechart echarts-wordcloud 生成人物词云图 词云 词少、形状问题、 解决办法
csy_119的博客
03-26 6万+
1. git官方地址： https://github.com/ecomfe/echarts-wordcloud 2. 需要 下载echarts包 和 echarts-wordcloud包 【npm install echarts 、npm install echarts-wordcloud】 const treeDataURI = ''; // 这里是图片的base64格式，为了方便阅读。我...
自动驾驶芯片调研
weixin_44523062的博客
09-08 5616
1 Mobileye 以色列 成立于1999年，是以色列提供基于视觉系统分析和数据处理研发高级驾驶辅助系统和自动驾驶解决方案的全球先行者，为全球27家OEM厂和Tier1厂商提供“芯片+算法”软硬一体化的ADAS视觉解决方案 中国造车新势力小鹏汽车曾短暂地用Mobileye的芯片做过测试后决定在P7上改用英伟达的Xavier，主要因为小鹏希望“把芯片和算法剥离开，采用可编程的芯片，在芯片上进行算法研发和定制化，跟场景结合”，因此选择了更开放的英伟达。 2 英伟达Xavier, 2020Orin-10到20
SNPE/QNN 使用
weixin_42136255的博客
03-28 2007
SNPE/QNN 使用
高通模型转换 Qnn /SNPE 安装
dubochao_xinxi的博客
01-10 1210
【代码】高通模型转换 Qnn /SNPE 安装。
Qualcomm® AI Engine Direct 使用手册（1）
weixin_38498942的博客
12-21 2146
本文档提供 Qualcomm® AI Engine Direct 软件开发套件 (SDK) 的参考指南。笔记Qualcomm® AI Engine Direct 在源代码和文档中也称为 Qualcomm 神经网络 (QNN)。Qualcomm® AI Engine Direct 是 Qualcomm Technologies Inc. (QTI) 用于 AI/ML 用例的软件架构 关于 QTI 芯片组和 AI 加速核心。
finn：在FPGA上进行QNN推理的数据流编译器
01-31
在FPGA上进行快速，可扩展的量化神经网络推理 FINN是Xilinx研究实验室的实验框架，旨在探索FPGA上的深度神经网络推理。 它专门针对，重点是生成为每个网络定制的数据流样式的体系结构。 由此产生的FPGA加速器是高效的，可以产生高吞吐量和低延迟。 该框架是完全开源的，以提供更高程度的灵活性，并且旨在使神经网络研究能够跨越软件/硬件抽象堆栈的多个层。 我们有一个单独的存储库 ，其中包含几个神经网络的预构建示例。 有关FINN的更多常规信息，请访问并查看。 入门 请参阅“页面，以获取有关需求，安装以及如何以不同模式运行FINN的更多信息。 由于项目依赖项的复杂性质，我们目前仅支持基于Docker的FINN编译器执行。 FINN有什么新功能？ 2020-12-17：发布了v0.5b（测试版），其中包括MobileNet-v1的新。 在 上阅读更多内容。 2020-09-21： v0.4b（beta）已发布。 在 上阅读更多内容。 2020-05-08： v0.3b（测试版）发布，最初支持卷积，并行转换，为MVAU提供更灵活的内存分配，吞吐量测试以及许多其他较小的改进和错误修
Stack3 java.rar_Stack3 java_palindrome
09-20
用堆栈实现回文算法 可以测试各种字符串 dos界面
Elastic Stack 技术指南
05-15
一本 Elastic Stack 技术指南，帮助大家厘清技术细节，分享一些实战案 例，成为我近半年一大心愿。
深度学习CNN
12-22 2904
HomePage:🚀B站项目实战🤵‍♂ CSDN个人主页。
贪心法
热门推荐
Me的专栏
05-07 21万+
贪心法 贪心算法并不是从整体最优上加以考虑， 而是从局部最优考虑， 每次总是做出当前看起来最好的选择，在某种意义上的局部最优选择； 最优子结构性质 ： 贪心选择性质： 1、  活动安排 ： 问题描述 ：设有n个活动集合E = {1 ,2,…,n} ，其中每个活动i都要求使用同一资源， 而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始
js实现ios头部导航条模糊效果
阳光下的木子林的博客
10-25 2万+
原文地址http://codepen.io/wmnsk/pen/GxCsL Document iOS 7 Blurred Header Mauris viv
蓝桥杯练习
ZZPIGKK的博客
04-07 3092
蓝桥杯
骁龙神经处理引擎SDK参考指南（5）
weixin_38498942的博客
05-18 388
一个 UDO 包主要由一个注册库和一个或多个实现库组成。主要思想是注册库包含有关操作性质的信息，而实现包含执行操作所需的内核（有关更多详细信息，请参阅UDO 概述）。UDO 包可以通过 UDO 配置来定义，它包含操作和路径的文本规范，最终将帮助定义将代表 UDO 包的目录结构。本节将讨论 UDO 包的定义，而定义包后的创建将推迟到创建UDO 包的部分。UDO 包配置说明在UDO 配置字段描述中找到的所有字段都被复制用于 UDO 包配置规范。
stack smashing detected ***: ./demo terminated Aborted (core dumped)
06-08
这是一个程序运行错误的提示信息，其中包含了错误类型和错误信息。根据提示信息，可以看到程序被检测到了栈溢出错误，导致程序异常终止，并且生成了一个核心转储文件(core dumped)。 栈溢出是一种常见的程序错误，它通常发生在函数调用时，当函数使用了过多的栈空间，或者使用了未经检查的用户输入数据，就有可能导致栈溢出错误。在这个错误信息中，程序被检测到了栈溢出错误，被系统检测到了，从而导致程序异常终止。 根据这个错误信息，我们可以考虑检查程序中使用了多少栈空间，是否存在未经检查的用户输入数据，以及是否存在数组越界等问题。如果无法确定具体原因，可以考虑在程序中添加调试信息，或者使用调试工具进行调试，找出错误的原因并进行修复。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值