TensorRT加速模型推断时间方法介绍（c++ pytorch模型）

置顶 已于 2022-06-18 14:45:01 修改
阅读量6.7k 收藏 7
点赞数 4
分类专栏： Python与深度学习 文章标签： pytorch c++ 人工智能 tensorrt
于 2022-03-14 23:29:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiugeshao/article/details/123454004
版权

 这里就用QTcreator来作为c++的IDE，其安装及opencv的配置（博主还是喜欢源码编译自己需要的opencv版本）过程见我之前的博客。       Ubuntu20.04 C++程序的简单编译及QT和Pycharm的配置_jiugeshao的专栏-CSDN博客_pycharm编译c++1. 使用gcc来编译c++程序,如下两个命令完成了创建c++程序及打开文本编辑程序2.拿牛客网上第HJ6求质数因子题（华为机试题库_在线编程+题解_牛客题霸_牛客网）代码进行测试，代码编辑如下：#include <iostream>using namespace std; int main(){ long n; cin>>n; for(int i=2;i*i<=n;i++) { while(.https://blog.csdn.net/jiugeshao/article/details/120406478?spm=1001.2014.3001.5502

Ubuntu下Qt Creator配置opencv_jiugeshao的专栏-CSDN博客1.首先记录下如何用Qt Creator做一个界面程序，新建一个项目如上选择后选择好路径，输入项目名称后，点击继续如下选择Desktop Qt 5.12.1 GCC 65bit选项，可以点击Details来做展开查看继续到如下界面可参照我之前的博客里做设计程序界面pcharm配置pyqt5(Anaconda3 python环境)做界面开发_jiugeshao的专栏-CSDN博客运行程序，点击界面上的show按钮，文本框内便出现了文本2. ...https://blog.csdn.net/jiugeshao/article/details/120578698?spm=1001.2014.3001.5502纯c++工程选择项

 进入项目后，help菜单下about plugins可以调出如下配置界面，取消标红框的勾选，不然可能会发现，没有输入提示功能。

 再一次跑一个opencv例子，正常运行。

准备工作结束后，开始进入主题部分：

主要还是参考官网，这里以自带例子sampleOnnxMNIST.cpp为蓝本进行改动。

 直接将代码复制到main.cpp（QTCreator所创建）中

工程配置信息如下，因为后面会用到opencv，这边也都添加了， 注意标红的框，如果不加，会报和gLogger相关的如下错误：

/home/sxhlvye/Trial/tensorrt_c++/test4/main.cpp:168: error: undefined reference to `sample::gLogger'

/home/sxhlvye/Trial/tensorrt_c++/test4/main.cpp:357: error: undefined reference to `sample::gLogError'

/home/sxhlvye/Trial/tensorrt_c++/test4/main.cpp:286: error: undefined reference to `sample::gLogInfo'

TEMPLATE = app
CONFIG += console c++11
CONFIG -= app_bundle
CONFIG -= qt

SOURCES += \
        main.cpp


INCLUDEPATH += /usr/local/include \
               /usr/local/include/opencv \
               /usr/local/include/opencv2 \
               /home/sxhlvye/Downloads/TensorRT-8.0.0.3/include \
               /home/sxhlvye/Downloads/TensorRT-8.0.0.3/samples/common \
               /home/sxhlvye/Downloads/TensorRT-8.0.0.3/samples/common/logger.cpp \
               /usr/local/cuda-11.0/include

LIBS += /usr/local/lib/libopencv_highgui.so \
        /usr/local/lib/libopencv_core.so \
        /usr/local/lib/libopencv_imgproc.so \
        /usr/local/lib/libopencv_imgcodecs.so \
        /usr/local/cuda-11.0/lib64/libcudart.so \
        /home/sxhlvye/Downloads/TensorRT-8.0.0.3/lib/libnvinfer.so \
        /home/sxhlvye/Downloads/TensorRT-8.0.0.3/targets/x86_64-linux-gnu/bin/common/logger.o \
        /home/sxhlvye/Downloads/TensorRT-8.0.0.3/lib/libnvparsers.so \
        /home/sxhlvye/Downloads/TensorRT-8.0.0.3/lib/libnvinfer_plugin.so \
        /home/sxhlvye/Downloads/TensorRT-8.0.0.3/lib/libnvonnxparser.so \

 这里直接使用前面已经转化好的Onnx模型（由pytorch模型实现转换而来，见前面博客）来测试。里面所用到的

imagenet_classes.txt见网址

详细代码如下（以官方自带例子sampleOnnxMNIST.cpp基础上进行的改写，大体分为将ONNX转化为engine, 然后读取图片进行归一化，再统计预测值），其中图片归一化是自己模仿前面博客中的归一化所写，短边375缩放至256，长边500等比例缩放至341，再做中心裁切，224x224大小，再减去均值，比上方差。

#include "argsParser.h"
#include "buffers.h"
#include "common.h"
#include "logger.h"
#include "parserOnnxConfig.h"

#include "NvInfer.h"
#include <cuda_runtime_api.h>

#include <opencv2/core/core.hpp>
#include <opencv2/opencv.hpp>

#include <cstdlib>
#include <fstream>
#include <iostream>
#include <sstream>

using namespace std;
using namespace cv;

class SampleOnnx
{
    template <typename T>
    using SampleUniquePtr = std::unique_ptr<T, samplesCommon::InferDeleter>;

public:
    SampleOnnx(const samplesCommon::OnnxSampleParams& params)
        : mParams(params)
        , mEngine(nullptr)
    {
    }

    //! \brief Function builds the network engine
    bool build();


    //! \brief Runs the TensorRT inference engine for this sample
    bool infer();

private:
    samplesCommon::OnnxSampleParams mParams; //!< The parameters for the sample.

    nvinfer1::Dims mInputDims;  //!< The dimensions of the input to the network.
    nvinfer1::Dims mOutputDims; //!< The dimensions of the output to the network.
    int mNumber{0};             //!< The number to classify

    std::shared_ptr<nvinfer1::ICudaEngine> mEngine; //!< The TensorRT engine used to run the network

    //! \brief Parses an ONNX model and creates a TensorRT network

    bool constructNetwork(SampleUniquePtr<nvinfer1::IBuilder>& builder,
        SampleUniquePtr<nvinfer1::INetworkDefinition>& network, SampleUniquePtr<nvinfer1::IBuilderConfig>& config,
        SampleUniquePtr<nvonnxparser::IParser>& parser);


    //! \brief Reads the input  and stores the result in a managed buffer
    bool processInput(const samplesCommon::BufferManager& buffers);


    //! \brief Classifies digits and verify result
    bool getOutput(const samplesCommon::BufferManager& buffers);
};

//!
//! \brief Creates the network, configures the builder and creates the network engine
//!
//! \details This function creates the Onnx network by parsing the Onnx model and builds
//!          the engine
//!
//! \return Returns true if the engine was created successfully and false otherwise
//!
bool SampleOnnx::build()
{
    auto builder = SampleUniquePtr<nvinfer1::IBuilder>(nvinfer1::createInferBuilder(sample::gLogger.getTRTLogger()));

    if (!builder)
    {
        return false;
    }


    const auto explicitBatch = 1U << static_cast<uint32_t>(NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
    auto network = SampleUniquePtr<nvinfer1::INetworkDefinition>(builder->createNetworkV2(explicitBatch));
    if (!network)
    {
        return false;
    }


    auto config = SampleUniquePtr<nvinfer1::IBuilderConfig>(builder->createBuilderConfig());
    if (!config)
    {
        return false;
    }

    auto parser = SampleUniquePtr<nvonnxparser::IParser>(nvonnxparser::createParser(*network, sample::gLogger.getTRTLogger()));
    if (!parser)
    {
        return false;
    }


    //In this function will use the onnx file path
    auto constructed = constructNetwork(builder, network, config, parser);
    if (!constructed)
    {
        return false;
    }


    mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(builder->buildEngineWithConfig(*network, *config), samplesCommon::InferDeleter());

    if (!mEngine)
    {
        return false;
    }

    ASSERT(network->getNbInputs() == 1);
    mInputDims = network->getInput(0)->getDimensions();
    ASSERT(mInputDims.nbDims == 4);

    ASSERT(network->getNbOutputs() == 1);
    mOutputDims = network->getOutput(0)->getDimensions();
    ASSERT(mOutputDims.nbDims == 2);

    return true;
}

//!
//! \brief Uses a ONNX parser to create the Onnx MNIST Network and marks the
//!        output layers
//!
//! \param network Pointer to the network that will be populated with the Onnx MNIST network
//!
//! \param builder Pointer to the engine builder
//!
bool SampleOnnx::constructNetwork(SampleUniquePtr<nvinfer1::IBuilder>& builder,
    SampleUniquePtr<nvinfer1::INetworkDefinition>& network, SampleUniquePtr<nvinfer1::IBuilderConfig>& config,
    SampleUniquePtr<nvonnxparser::IParser>& parser)
{

    auto parsed = parser->parseFromFile(mParams.onnxFileName.c_str() , static_cast<int>(sample::gLogger.getReportableSeverity()));
    if (!parsed)
    {
        return false;
    }

    config->setMaxWorkspaceSize(512_MiB);
    if (mParams.fp16)
    {
        config->setFlag(BuilderFlag::kFP16);
    }
    if (mParams.int8)
    {
        config->setFlag(BuilderFlag::kINT8);
        samplesCommon::setAllDynamicRanges(network.get(), 127.0f, 127.0f);
    }

    samplesCommon::enableDLA(builder.get(), config.get(), mParams.dlaCore);

    return true;
}

//!
//! \brief Runs the TensorRT inference engine for this sample
//!
//! \details This function is the main execution function of the sample. It allocates the buffer,
//!          sets inputs and executes the engine.
//!
bool SampleOnnx::infer()
{
    // Create RAII buffer manager object
    samplesCommon::BufferManager buffers(mEngine);

    auto context = SampleUniquePtr<nvinfer1::IExecutionContext>(mEngine->createExecutionContext());
    if (!context)
    {
        return false;
    }

    //Read the image into the managed buffers
    ASSERT(mParams.inputTensorNames.size() == 1);

    if (!processInput(buffers))
    {
        return false;
    }

    // Memcpy from host input buffers to device input buffers
    buffers.copyInputToDevice();

    bool status = context->executeV2(buffers.getDeviceBindings().data());
    if (!status)
    {
        return false;
    }

    // Memcpy from device output buffers to host output buffers
    buffers.copyOutputToHost();

    // Verify results
    if (!getOutput(buffers))
    {
        return false;
    }

    return true;
}

//!
//! \brief Reads the input and stores the result in a managed buffer
//!
bool SampleOnnx::processInput(const samplesCommon::BufferManager& buffers)
{
    cout << "mINputDims.d[0]" << mInputDims.d[0] << std::endl;
    cout << "mINputDims.d[1]" << mInputDims.d[1] << std::endl;
    cout << "mINputDims.d[2]" << mInputDims.d[2] << std::endl;
    cout << "mINputDims.d[3]" << mInputDims.d[3] << std::endl;

    cv::Mat image = cv::imread("/home/sxhlvye/Trial/yolov3-9.5.0/2008_002682.jpg", cv::IMREAD_COLOR);
    cv::cvtColor(image, image, cv::COLOR_BGR2RGB);
    cout << image.channels() << "," << image.size().width << "," << image.size().height << std::endl;

    cv::Mat dst = cv::Mat::zeros(341, 256, CV_32FC3);
    cv::resize(image, dst, dst.size());
    cout << dst.channels() << "," << dst.size().width << "," << dst.size().height << std::endl;

    cv::Mat dst1 = dst(Range(58, 282), Range(16, 240)).clone();
    cout << dst1.channels() << "," << dst1.size().width << "," << dst1.size().height << std::endl;

    static const float mean[3] = { 0.485f, 0.456f, 0.406f };
    static const float Std[3] = { 0.229f, 0.224f, 0.225f };

    const int channel = mInputDims.d[1];
    const int inputH = mInputDims.d[2];
    const int inputW = mInputDims.d[3];
    // Read a random digit file

    std::vector<float> fileData(inputH * inputW * channel);

    for (int c = 0; c < channel; ++c)
    {
        for (int i = 0; i < dst1.rows; ++i)
        {
            cv::Vec3b *p1 = dst1.ptr<cv::Vec3b>(i);
            for (int j = 0; j < dst1.cols; ++j)
            {
                fileData[c * dst1.cols * dst1.rows + i * dst1.cols + j] = (p1[j][c] / 255.0f - mean[c]) / Std[c];
            }
        }
    }


    float* hostDataBuffer = static_cast<float*>(buffers.getHostBuffer(mParams.inputTensorNames[0]));
    for (int i = 0; i < inputH * inputW * channel; i++)
    {
        hostDataBuffer[i] = fileData[i];
    }


    return true;
}

bool cmp(int a,int b)
{
    return a>b;
}
//! \brief Classifies digits and verify result
//!
//! \return whether the classification output matches expectations
//!
//!
//!

bool SampleOnnx::getOutput(const samplesCommon::BufferManager& buffers)
{
    const int outputSize = mOutputDims.d[1];
    std::cout << "outputSize: " << outputSize << std::endl;
    float* output = static_cast<float*>(buffers.getHostBuffer(mParams.outputTensorNames[0]));
    float val{0.0f};
    int idx{0};

    // Calculate Softmax
    float sum{0.0f};
    for (int i = 0; i < outputSize; i++)
    {
        output[i] = exp(output[i]);
        sum += output[i];
    }

    sample::gLogInfo << "Output:" << std::endl;
    for (int i = 0; i < outputSize; i++)
    {
        output[i] /= sum;
    }

    vector<float> voutput(1000);
    for (int i = 0; i < outputSize; i++)
    {
        voutput[i] = output[i];
    }

    for(int i=0; i<1000; i++)
    {
        for(int j= i+1; j< 1000; j++)
        {
            if(output[i] < output[j])
            {
                int temp;
                temp = output[i];
                output[i] = output[j];
                output[j] = temp;
            }
        }
    }

    for(int i=0; i<5;i++)
    {
        cout << output[i] << std::endl;
    }

    vector<string> labels;
    string line;

    ifstream readFile("/home/sxhlvye/Trial/yolov3-9.5.0/imagenet_classes.txt");
    while (getline(readFile,line))
    {
        //istringstream record(line);
        //string label;
       // record >> label;
        cout << line << std::endl;
        labels.push_back(line);
    }

    vector<int> indexs(5);

    for(int i=0; i< 1000;i++)
    {
        if(voutput[i] == output[0])
        {
            indexs[0] = i;
        }

        if(voutput[i] == output[1])
        {
            indexs[1] = i;
        }

        if(voutput[i] == output[2])
        {
            indexs[2] = i;
        }

        if(voutput[i] == output[3])
        {
            indexs[3] = i;
        }
        if(voutput[i] == output[4])
        {
            indexs[4] = i;
        }

    }



    cout << "top 5: " << std::endl;

    cout << labels[indexs[0]] << "--->" << output[0] << std::endl;

    cout << labels[indexs[1]] << "--->" << output[1] << std::endl;

    cout << labels[indexs[2]] << "--->" << output[2] << std::endl;

    cout << labels[indexs[3]] << "--->" << output[3] << std::endl;

    cout << labels[indexs[4]] << "--->" << output[4] << std::endl;



    return true;
}

int main()
{
    samplesCommon::OnnxSampleParams params;

    params.onnxFileName = "/home/sxhlvye/Trial/yolov3-9.5.0/vgg16.onnx";
    params.inputTensorNames.push_back("input");
    params.outputTensorNames.push_back("output");
    params.fp16 = false;
    params.int8 = false;
    params.batchSize = 1;

    SampleOnnx sampleonnx(params);

    //step1: covert onnx to tensorrt, and can get a engine
    if (!sampleonnx.build())
    {
        std::cout << "conver oNNX to Tensorrt fail!" << std::endl;
    }

    std::cout << "conver oNNX to Tensorrt ok!" << std::endl;


    if (!sampleonnx.infer())
    {
      std::cout << "infer fail!" << std::endl;
    }

    std::cout << "infer ok!" << std::endl;

}

运行结果如下：

虽然top5预测值和前面博客不一致(一些预处理方面可能带来了差异），但按最大得分预测值都为tigger cat

 pytorch python版的加速见我的博客：

TensorRT加速方法介绍（python pytorch模型）_jiugeshao的专栏-CSDN博客_tensorrt加速pytorchhttps://blog.csdn.net/jiugeshao/article/details/123141499?spm=1001.2014.3001.5502

竹叶青lvye
关注
专栏目录
【AI】PyTorch实战（四）：使用C++调用PyTorch模型
郭老二
10-24 3805
PyTorch是由python语言实现，想要使用C++调用PyTorch模型，需要先将PyTorch模型的结构和参数保存成一种和具体编程语言无关的格式，然后使用C++来解析这种格式即可。TorchScript程序就是使用python语言，将PyTorch模型的结构和参数保存下来，这一操作称为序列化。PyTorch提供C++接口库——libTorch，该库用于加载已经序列化的PyTorch模型，这一操作称为反序列化。
五、yolov8 tensorRT c++部署及接口封装（保姆级教程&附源码）
机器视觉、深度学习、C++、opencv、halcon、图像算法
04-25 1761
onnx转engine保姆级教程，附带源码
TensorRT 下不同 API 推理时间的对比实验
zi_y_uan的博客
05-20 1万+
主要对比TensoRT C++ api、python api，在onnxparser和原生api构建网络方面的加速效果
使用C++编写接口调用PyTorch模型，并生成DLL供.NET使用
最新发布
LiRongLu_的博客
09-02 1163
介绍了如何将PyTorch模型保存为TorchScript格式，并创建基于CUDA加速的C++接口。首先，使用Python脚本将PyTorch模型导出为TorchScript格式，详细说明了如何加载模型、配置参数并保存为.pt文件。接着，使用C++编写接口，展示如何通过ONNX Runtime和CUDA执行推理操作。该部分提供了从项目创建到DLL生成的完整步骤，涵盖了配置Visual Studio项目、链接库文件、实现推理逻辑等内容。最后，还介绍了如何在其他环境中调用生成的DLL文件，实现模型的跨平台推理。
[c++]-利用chrono标准库实现c++毫秒级精准计时,完成图像推理时间计算，并输出FPS
ai_faker的博客
05-25 2856
资源 Date and time utilities - C++ Reference 简介 在计算机视觉中我们可能经常需要计算一次推理的耗时，来得到确定的FPS，查了很多其他方法，尤其是clock()这个方法对于ms级计时来说也太不准了。这些方法都太古老了，有的还要区分电脑是不是win。终于被我找到了c++11中的标准库--chrono，又准又快！ 不想看罗嗦的介绍的同学可以直接看 1.2中 标黄的例子 1.chrono介绍 主要包含如下的几部分 Clocks system_clock steady
TVM VS TensorRT推理速度比较
shelgi的博客
10-08 1560
上个结果对比框架平均推理时间(ms)最大推理时间(ms)最小推理时间(ms)TensorRT0.31950.63370.3023TVM Base0.76721.64670.6861TVM Tune0.56521.06230.5562费了九牛二虎之力调优出来的模型还是比不过TensorRT的推理速度,七小时调优只减少0.2ms的推理时间,但起码模型的稳定性得到了提升还是有些许安慰的.
C++调pytorch模型的全过程记录
己亥谷雨
10-30 2775
前面已经记录过了，流程就是这么个流程： 配置libtorch --->python训练的模型怎么在C++使用？_己亥谷雨-CSDN博客 pytorch模型转化 编写C++调用程序 这里就来记录一下模型转化和C++调用程序。 关于模型的训练就不多说了，不会训练模型还扯什么调用。 好在之前记录过一点： 训练模型PyTorch：VGG16简单入门版_己亥谷雨-CSDN博客 保存测试模型PyTorch：保存/加载训练好的模型测试_己亥谷雨-CSDN博客_pytorch训练好的模型去检测 ==..
onnx模型部署 python_ONNX 介绍及TensorRT部署
weixin_39768247的博客
12-15 3083
ONNX简介Open Neural Network Exchange(ONNX，开放神经网络交换)格式，是一个用于表示深度学习模型的标准，可使模型在不同框架之间进行转移。【ONNX是一种针对机器学习所设计的开放式的文件格式，用于存储训练好的模型。它使得不同的人工智能框架(如Pytorch, MXNet)可以采用相同格式存储模型数据并交互。 ONNX的规范及代码主要由微软，亚马逊 ，Facebook...
【干货】用tensorRT加速yolov5全记录，包含加速前后的数据对比
热门推荐
Activewaste
11-25 1万+
TensorRT 实现模型yolov5的加速，附自己测的数据对比安装tensorRT首先了解自己ubuntu、CUDA和cuDNN版本安装TensorRT可能出现的问题：使用tensorRT加速LeNet进行验证tensorRT加速yolov5加速前后效果对比 安装tensorRT 前言：这里仅记录博主自己用tar安装tyensorRT的流程，对于DEV版本等的安装，请移步其他博客。使用tar安装是博主认为相对比较简单的方式了，要注意的是解压版的tar需要我们手动去修改lib的路径，如果是使用安装版的，就不
(ubuntu 18.04 cuda 10.2 pytorch onnx→tensorrt) 使用tensorrt加载并运行onnx模型
heiha1232的博客
04-15 901
2021.4 ubuntu 18.04 cuda 10.2 pytorch onnx→tensorrt使用tensorrt加载并运行onnx模型0. TensorRT介绍1. 安装tensorrt、pycuda1.1 安装tensorrt1.2 安装pycuda2. 将pytorch模型转化为onnx模型3. tensorrt调用onnx模型进行预测4. 注意事项 0. TensorRT介绍 https://docs.nvidia.com/deeplearning/tensorrt/developer-gu
Yolov5模型在TensorRT上的C++部署及性能优势
5. 推理速度的提升：通过TensorRT进行模型推理相较于使用其他框架，如ONNX Runtime，能显著减少推理时间，实现实时性较高的应用。 6. 在压缩包文件a.txt中，可能包含了上述流程的详细步骤，代码示例，配置说明或者...
c++计算程序时间
翻肚鱼儿的博客
08-21 213
#include<iostream> #include<windows.h> int main() { DWORD start_time=GetTickCount(); { //此处为被测试代码 } DWORD end_time=GetTickCount(); cout<<"The run time is:"<<(end_time-start_time)<<"ms!"<<endl;//输出运行时间 return 0; } 1 2 .
C++/OpenCV 计算模块执行时间方法
泠山的博客
06-10 675
计算模块执行时间方法1. OpenCV1.1 使用方式 Reference： OpenCV 利用getTickCount()与getTickFrequency()计算执行时间 1. OpenCV OpenCV 中使用 getTickCount() 和 getTickFrequency() 计算执行时间，两个API均被定义在了core.hpp文件下。 1.1 使用方式 auto start_time = cv::getTickCount(); ... ... auto end_time = cv::g
tensorRT部署时间测试
zhouzongzong的博客
07-09 269
tensorRT部署时间测试
【tensorrt】——trtexec动态batch支持与batch推理耗时评测
怡宝2号
09-06 8031
tensorrt, batch 1. trtexec编译 trtexec地址 参考官方的说明，进行项目编译 2. 模型转换 pytorch->onnx的时候，需要在动态尺寸上定义好，例如： dynamic_axes = { 'input': {0: 'batch_size'}, # } torch.onnx.export(model, # model being run x, # model input (or a tuple for mu.
NVIDIA相关资料（二）——TensorRT加速深度学习推理计算
小刺猬的宝藏笔记本
04-21 2795
NVIDIA教你用TensorRT加速深度学习推理计算
TensorRT对TensorFlow模型进行推理
shajiayu1的博客
02-25 2362
目录一、工程介绍二、这个工程如何工作起来三、tensorRT API的层和节点四、运行这个示例 一、工程介绍 这个示例sampleUffMNIST是一个对TensorFlow模型进行推理的示例。MNIST TensorFlow 模型被转换成UFF文件。UFF文件用图表的方式存储神经网络。 NvUffParser 在该示例中被使用去解析 UFF文件，从而创建该神经网络的推理引擎。使用TensorRT...
【标题 C++环境下tensorrt加速推理部署测试】
yezlin的博客
11-04 1367
延续上一篇，基于yolov5利用C++进行检测分类测试。C++环境下tensorrt加速推理部署测试。
使用某个FP16的TRT目标检测模型在Tesla T4上推理一张入网尺寸为1000万像素的图片，推理时间约为200ms，则使用该模型推理入网尺寸为2500万像素的图片，时间约为 ...
weixin_35749545的博客
01-14 152
使用某个FP16的TRT目标检测模型在Tesla T4上推理一张入网尺寸为2500万像素的图片，时间约为500ms。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

竹叶青lvye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值