深度学习模型部署TensorRT加速（四）：TensorRT的应用场景及部署模块应用

编程语言 2023-10-03 17:49:25 阅读次数: 0

篇章四：TensorRT的应用场景及部署模块应用

目录

一、TensorRT的应用场景

二、TensorRT部署的常用方法（重点！！！）

三 TensorRT 模块（重点！！！）

        3.1 Layer Fusion

        3.2 Kernel Auto-tuning

        3.3 Qualization量化

PS:纯粹为学习分享经验，不参与商用价值运作，若有侵权请及时联系！！！

下一篇内容预告：深度学习模型部署TensorRT加速（五）：TensorRT部署流程及基本使用

一、TensorRT的应用场景

TensorRT在深度学习推理任务中有广泛的应用场景。以下是一些常见的应用场景：

  1. 边缘计算和嵌入式系统：TensorRT可以在边缘设备和嵌入式系统上实现高效的深度学习推理。通过优化和部署深度学习模型，TensorRT可以提供快速、低功耗的推理能力，使得在资源受限的设备上进行实时的边缘推理成为可能。

  2. 视觉和图像处理：TensorRT在计算机视觉和图像处理领域具有广泛的应用。它可以用于图像分类、目标检测、人脸识别、图像分割等任务。TensorRT的优化技术可以加速这些任务的推理速度，提高实时性能。

  3. 语音和语音识别：TensorRT可用于语音处理和语音识别应用。它可以用于语音情感分析、语音识别模型的推理加速等任务。TensorRT的优化技术可以提高语音处理任务的推理效率和实时性能。

  4. 自然语言处理：TensorRT也可以应用于自然语言处理（NLP）任务。例如，文本分类、情感分析、机器翻译等任务可以通过TensorRT进行优化和加速，提高NLP任务的推理速度。

  5. 智能视频分析：TensorRT可以用于视频分析和智能视频监控应用。例如，对象跟踪、行为识别、实时视频分割等任务可以通过TensorRT进行加速，实现实时的视频分析和智能决策。

        需要注意的是，TensorRT适用于各种深度学习框架训练的模型，如TensorFlow、PyTorch、ONNX等。它提供了与这些框架的集成接口，使得将模型优化和部署到TensorRT的运行时环境中变得更加简单和高效。

二、TensorRT部署的常用方法（重点！！！）

        TensorRT提供了多种常用的部署方法，以将优化后的深度学习模型部署到目标环境中。以下是一些常见的TensorRT部署方法：

  1. Python API：TensorRT提供了Python API，可以使用Python编写脚本来构建、优化和执行深度学习模型。可以使用TensorRT的Python API加载模型、定义输入输出张量、执行推理，并获取推理结果。这种方法适用于需要灵活性和可扩展性的部署场景。

    import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

# 定义向量大小
vector_size = 1000

# 生成两个随机向量
a = np.random.randn(vector_size).astype(np.float32)
b = np.random.randn(vector_size).astype(np.float32)

# 在GPU上分配内存
a_gpu = cuda.mem_alloc(a.nbytes)
b_gpu = cuda.mem_alloc(b.nbytes)
result_gpu = cuda.mem_alloc(a.nbytes)

# 将数据从主机内存复制到GPU内存
cuda.memcpy_htod(a_gpu, a)
cuda.memcpy_htod(b_gpu, b)

# 编写CUDA核心函数
kernel_code = """
__global__ void add_vectors(float *a, float *b, float *result) {
    int idx = threadIdx.x;
    result[idx] = a[idx] + b[idx];
}
"""

# 编译CUDA核心函数
from pycuda.compiler import SourceModule
mod = SourceModule(kernel_code)

# 获取CUDA核心函数
add_vectors = mod.get_function("add_vectors")

# 执行CUDA核心函数
block_size = (vector_size, 1, 1)
grid_size = (1, 1)
add_vectors(a_gpu, b_gpu, result_gpu, block=block_size, grid=grid_size)

# 从GPU内存复制结果到主机内存
cuda.memcpy_dtoh(a, result_gpu)

# 打印结果
print("Result:", a)

  2. TensorFlow集成：TensorRT与TensorFlow深度集成，提供了TensorFlow的TensorRT插件。可以使用TensorFlow框架训练模型，并使用TensorRT插件将训练好的模型转换为TensorRT可执行的引擎。这种方法使得将TensorFlow模型与TensorRT一起使用变得更加简单和无缝。

    #include <iostream>
#include <tensorflow/core/public/session.h>
#include <tensorflow/core/platform/env.h>

int main() {
    // 创建TensorFlow会话
    tensorflow::Session* session;
    tensorflow::Status status = tensorflow::NewSession(tensorflow::SessionOptions(), &session);

    if (!status.ok()) {
        std::cerr << "Error creating TensorFlow session: " << status.ToString() << std::endl;
        return 1;
    }

    // 加载TensorFlow模型
    tensorflow::GraphDef graph_def;
    tensorflow::Status load_status = tensorflow::ReadBinaryProto(tensorflow::Env::Default(), "path/to/your/model.pb", &graph_def);

    if (!load_status.ok()) {
        std::cerr << "Error loading TensorFlow model: " << load_status.ToString() << std::endl;
        return 1;
    }

    // 将模型图加载到会话中
    tensorflow::Status create_status = session->Create(graph_def);

    if (!create_status.ok()) {
        std::cerr << "Error creating TensorFlow graph: " << create_status.ToString() << std::endl;
        return 1;
    }

    // 准备输入数据
    // ...

    // 创建输入Tensor
    tensorflow::Tensor input_tensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({1, inputSize}));
    // 填充输入Tensor
    // ...

    // 运行推理
    std::vector<std::pair<std::string, tensorflow::Tensor>> inputs = {
     
     {"input_node_name", input_tensor}};
    std::vector<tensorflow::Tensor> outputs;

    tensorflow::Status run_status = session->Run(inputs, {"output_node_name"}, {}, &outputs);

    if (!run_status.ok()) {
        std::cerr << "Error running TensorFlow inference: " << run_status.ToString() << std::endl;
        return 1;
    }

    // 处理推理结果
    // ...

    // 释放资源
    session->Close();
    delete session;

    return 0;
}

  3. ONNX集成：TensorRT与ONNX（Open Neural Network Exchange）深度集成，可以直接加载和优化ONNX格式的深度学习模型。通过将模型转换为ONNX格式，然后使用TensorRT加载和执行优化后的模型，实现高效的推理过程。

    #include <iostream>
#include <onnxruntime/core/providers/cpu/cpu_provider_factory.h>
#include <onnxruntime/core/providers/cpu/cpu_execution_provider.h>
#include <onnxruntime/core/providers/providers.h>

int main() {
    // 初始化ONNX Runtime环境
    OrtEnv* env;
    OrtStatus* status = OrtCreateEnv(ORT_LOGGING_LEVEL_WARNING, "ONNX_Runtime", &env);

    // 加载ONNX模型
    const char* modelPath = "path/to/your/model.onnx";
    OrtSession* session;
    status = OrtCreateSession(env, modelPath, nullptr, &session);

    // 检查模型输入和输出信息
    OrtSessionGetInputCount(session, &inputCount);
    OrtSessionGetOutputCount(session, &outputCount);

    std::cout << "Input Count: " << inputCount << std::endl;
    std::cout << "Output Count: " << outputCount << std::endl;

    // 准备输入数据
    // ...

    // 创建ONNX模型输入和输出的 OrtValue 对象
    OrtValue* inputs = new OrtValue[inputCount];
    OrtValue* outputs = new OrtValue[outputCount];

    // 将输入数据填充到 OrtValue 对象
    // ...

    // 运行推理
    OrtStatus* runStatus = OrtRun(session, nullptr, inputNames, inputs, inputCount, outputNames, outputs, outputCount);

    if (runStatus != nullptr)

  4. C++ API：TensorRT还提供了C++ API，可以使用C++编写代码来构建和部署深度学习模型。C++ API提供了与TensorRT的底层交互，使能够更精细地控制模型的优化和执行过程。这种方法适用于对性能和低级控制有更高要求的场景。

    #include <iostream>
#include <cuda_runtime.h>

// CUDA核心函数，将两个向量相加
__global__ void addVectors(float* a, float* b, float* result, int size) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < size) {
        result[idx] = a[idx] + b[idx];
    }
}

int main() {
    int vectorSize = 1000;
    int blockSize = 256; // CUDA线程块大小

    // 分配主机内存并初始化向量
    float* hostA = new float[vectorSize];
    float* hostB = new float[vectorSize];
    float* hostResult = new float[vectorSize];

    for (int i = 0; i < vectorSize; ++i) {
        hostA[i] = i;
        hostB[i] = i * 2;
    }

    // 分配GPU内存
    float* deviceA, * deviceB, * deviceResult;
    cudaMalloc((void**)&deviceA, vectorSize * sizeof(float));
    cudaMalloc((void**)&deviceB, vectorSize * sizeof(float));
    cudaMalloc((void**)&deviceResult, vectorSize * sizeof(float));

    // 将数据从主机内存复制到GPU内存
    cudaMemcpy(deviceA, hostA, vectorSize * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(deviceB, hostB, vectorSize * sizeof(float), cudaMemcpyHostToDevice);

    // 计算CUDA执行所需的线程块和网格大小
    int numBlocks = (vectorSize + blockSize - 1) / blockSize;
    
    // 调用CUDA核心函数
    addVectors<<<numBlocks, blockSize>>>(deviceA, deviceB, deviceResult, vectorSize);

    // 将结果从GPU内存复制回主机内存
    cudaMemcpy(hostResult, deviceResult, vectorSize * sizeof(float), cudaMemcpyDeviceToHost);

    // 打印结果
    for (int i = 0; i < vectorSize; ++i) {
        std::cout << "Result[" << i << "] = " << hostResult[i] << std::endl;
    }

    // 释放内存
    delete[] hostA;
    delete[] hostB;
    delete[] hostResult;
    cudaFree(deviceA);
    cudaFree(deviceB);
    cudaFree(deviceResult);

    return 0;
}

  5. Jetson平台集成：如果使用的是NVIDIA的Jetson平台（如Jetson Nano、Jetson Xavier），TensorRT可以与Jetson平台的JetPack SDK集成。JetPack SDK提供了Jetson平台上TensorRT的预装和配置，使能够轻松地部署和执行优化后的模型。

       具体的选择取决于应用场景、使用的深度学习框架以及目标硬件平台。在使用TensorRT进行部署时，可以根据需求和环境选择适合的部署方法。
 

三 TensorRT 模块（重点！！！）

3.1 Layer Fusion

        TensorRT的Layer Fusion（层融合）是一种优化技术，用于将多个神经网络层融合成一个更大的层，以减少内存访问和计算开销，提高推理性能。Layer Fusion可以在TensorRT的优化过程中自动应用，以减少推理过程中的计算和内存操作。通过Layer Fusion，TensorRT可以优化和简化模型的计算图，可以在推理过程中显著提升性能。

        其目标是减少内存访问和计算的次数，从而提高推理的效率。在神经网络中，不同层之间的计算和数据传输可能涉及多次内存访问和操作。通过将多个层融合为一个层，可以减少这些内存操作，从而减少内存带宽和延迟，并提高计算效率。

 Python代码示例：

import tensorrt as trt

# 创建TensorRT的Builder对象
builder = trt.Builder(trt.Logger(trt.Logger.WARNING))

# 创建TensorRT的NetworkDefinition对象
network = builder.create_network()

# 添加输入层和卷积层到网络
input_shape = (3, 224, 224)
input_layer = network.add_input(name="input", dtype=trt.float32, shape=input_shape)
conv_layer = network.add_convolution(input=input_layer, num_output_maps=64, kernel_shape=(3, 3))

# 设置卷积层的其他参数

# 启用Layer Fusion优化
flags = 1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_PRECISION)
network.set_flags(flags)

# 构建TensorRT的Engine
engine = builder.build_cuda_engine(network)

# 保存Engine到文件，以便以后加载和使用
trt.utils.write_engine_to_file("model.engine", engine)

# 释放资源
network.destroy()
builder.destroy()

C++代码示例：

#include <iostream>
#include <NvInfer.h>

int main()
{
    // 创建TensorRT的Builder对象
    nvinfer1::IBuilder* builder = nvinfer1::createInferBuilder(gLogger);

    // 创建TensorRT的NetworkDefinition对象
    nvinfer1::INetworkDefinition* network = builder->createNetwork();

    // 添加输入层和卷积层到网络
    nvinfer1::Dims inputDims{3, 224, 224};
    nvinfer1::ITensor* inputLayer = network->addInput("input", nvinfer1::DataType::kFLOAT, inputDims);
    nvinfer1::IConvolutionLayer* convLayer = network->addConvolution(*inputLayer, 64, nvinfer1::DimsHW{3, 3});

    // 设置卷积层的其他参数

    // 启用Layer Fusion优化
    network->setFlag(nvinfer1::NetworkDefinitionCreationFlag::kEXPLICIT_PRECISION);

    // 构建TensorRT的Engine
    nvinfer1::ICudaEngine* engine = builder->buildCudaEngine(*network);

    // 保存Engine到文件，以便以后加载和使用
    nvinfer1::IHostMemory* modelStream = engine->serialize();
    std::ofstream outFile("model.engine", std::ios::binary);
    outFile.write(reinterpret_cast<const char*>(modelStream->data()), modelStream->size());

    // 释放资源
    outFile.close();
    modelStream->destroy();
    engine->destroy();
    network->destroy();
    builder->destroy();

    return 0;
}

         Layer Fusion可以应用于具有特定模式的层之间，例如卷积层和批量归一化层的融合。融合后的层将同时执行卷积计算和批量归一化操作，避免了中间结果的内存传输和额外的计算步骤，从而提高了性能。

3.2 Kernel Auto-tuning

        Kernel Auto-tuning（自动调优）层是一种优化技术，用于自动选择和调整适合硬件平台的卷积核（kernel）的配置和参数。这个过程可以通过评估和选择不同的卷积算法、内存布局、线程块大小等来实现，以找到最佳的性能配置。

        自动调优层在TensorRT的优化过程中发挥着重要作用，它可以针对不同的硬件平台和配置选择最佳的卷积算法和参数，以实现最优的推理性能。这样可以确保卷积操作在特定硬件上得到充分利用，提高推理效率和吞吐量。

        在自动调优层中，TensorRT会根据硬件平台的特性和配置，自动尝试不同的卷积算法和参数，然后进行性能评估和比较。基于这些评估结果，TensorRT会选择最佳的配置，并生成优化后的卷积操作代码。这样可以根据硬件平台的不同，获得最佳的推理性能。

 Python代码示例：

import tensorrt as trt

# 创建TensorRT的Builder对象
builder = trt.Builder(trt.Logger(trt.Logger.WARNING))

# 创建TensorRT的NetworkDefinition对象
network = builder.create_network()

# 添加输入层和其他层到网络
input_shape = (3, 224, 224)
input_layer = network.add_input(name="input", dtype=trt.float32, shape=input_shape)
# 添加其他层到网络

# 构建TensorRT的Engine
builder.max_workspace_size = 1 << 30  # 设置最大的工作空间大小
builder.int8_mode = True  # 启用INT8量化模式
builder.fp16_mode = True  # 启用FP16精度模式
engine = builder.build_cuda_engine(network)

# 创建TensorRT的执行上下文
context = engine.create_execution_context()

# 创建输入和输出Tensor
input_data = np.random.random(input_shape).astype(np.float32)
output_data = np.empty(output_shape, dtype=np.float32)

# 将输入数据拷贝到GPU内存
input_buf = cuda.mem_alloc(input_data.nbytes)
cuda.memcpy_htod(input_buf, input_data)

# 分配输出Tensor的内存
output_buf = cuda.mem_alloc(output_data.nbytes)

# 执行推理
bindings = [int(input_buf), int(output_buf)]
context.execute_v2(bindings)

# 将输出数据从GPU内存拷贝回主机内存
cuda.memcpy_dtoh(output_data, output_buf)

# 释放资源
context.destroy()
engine.destroy()
network.destroy()
builder.destroy()

C++代码示例：

#include <iostream>
#include <NvInfer.h>

int main()
{
    // 创建TensorRT的Builder对象
    nvinfer1::IBuilder* builder = nvinfer1::createInferBuilder(gLogger);

    // 创建TensorRT的NetworkDefinition对象
    nvinfer1::INetworkDefinition* network = builder->createNetwork();

    // 添加输入层和其他层到网络
    nvinfer1::Dims inputDims{3, 224, 224};
    nvinfer1::ITensor* inputLayer = network->addInput("input", nvinfer1::DataType::kFLOAT, inputDims);
    // 添加其他层到网络

    // 构建TensorRT的Engine
    builder->setMaxWorkspaceSize(1 << 30);  // 设置最大的工作空间大小
    builder->setInt8Mode(true);  // 启用INT8量化模式
    builder->setFp16Mode(true);  // 启用FP16精度模式
    nvinfer1::ICudaEngine* engine = builder->buildCudaEngine(*network);

    // 创建TensorRT的执行上下文
    nvinfer1::IExecutionContext* context = engine->createExecutionContext();

    // 创建输入和输出Tensor
    float* input_data = new float[inputDims.d[0] * inputDims.d[1] * inputDims.d[2]];
    // 填充输入数据
    // 创建其他层的输出Tensor

    // 将输入数据拷贝到GPU内存
    cudaMemcpy(input_buf, input_data, inputDims.d[0] * inputDims.d[1] * inputDims.d[2] * sizeof(float), cudaMemcpyHostToDevice);

    // 分配输出Tensor的内存
    float* output_data = new float[outputDims.d[0] * outputDims.d[1] * outputDims.d[2]];
    // 创建其他层的输出Tensor的内存

    // 执行推理
    void* bindings[] = {input_buf, output_buf};
    context->executeV2(bindings);

    // 将输出数据从GPU内存拷贝回主机内存
    cudaMemcpy(output_data, output_buf, outputDims.d[0] * outputDims.d[1] * outputDims.d[2] * sizeof(float), cudaMemcpyDeviceToHost);

    // 释放资源
    delete[] input_data;
    delete[] output_data;
    context->destroy();
    engine->destroy();
    network->destroy();
    builder->destroy();

    return 0;
}

        通过自动调优层，TensorRT可以根据不同的硬件平台进行细粒度的优化，充分发挥硬件的计算能力和特性。这对于不同的GPU架构、型号和配置来说尤为重要，因为它们在卷积操作上的最佳配置可能会有所不同。

        需要注意的是，自动调优层是TensorRT在优化过程中自动应用的一部分，开发者通常不需要手动干预或调整。TensorRT会自动选择和配置最佳的卷积算法和参数，以实现最佳的推理性能。

3.3 Qualization量化

        Quantization（量化）是一种优化技术，用于将深度学习模型中的浮点数参数和激活值转换为较低精度的数据表示，从而减少内存使用和计算开销。量化技术可以在保持模型准确性的同时，提高模型的推理性能和效率。

        在深度学习模型中，浮点数通常使用32位（单精度）或16位（半精度）来表示，而量化技术可以将它们转换为更低精度的整数表示。常见的量化精度包括8位整数（INT8）、4位整数（INT4）甚至更低的精度。

量化技术通常分为两个步骤：权重量化和激活量化。

  1. 权重量化（Weight Quantization）：权重量化将模型的权重参数从浮点数转换为低精度整数。通常采用的方法是使用量化算法（如最大最小值量化、均匀量化等），将浮点数权重映射到离散的整数值，并存储为量化后的权重。

  2. 激活量化（Activation Quantization）：激活量化将模型的激活值从浮点数转换为低精度整数。激活量化通常在推理过程中应用，通过将激活值映射到量化后的整数表示，减少内存使用和计算开销。在激活量化过程中，通常会使用缩放因子（scale factor）来映射浮点数激活值到整数表示。

        通过量化，可以在保持模型准确性的前提下，加速模型的推理过程，并在资源有限的边缘设备上实现实时的推理。其实现代码如下：
Python代码示例：

import tensorrt as trt

# 创建TensorRT的Builder对象
builder = trt.Builder(trt.Logger(trt.Logger.WARNING))

# 创建TensorRT的NetworkDefinition对象
network = builder.create_network()

# 添加输入层和其他层到网络
input_shape = (3, 224, 224)
input_layer = network.add_input(name="input", dtype=trt.float32, shape=input_shape)
# 添加其他层到网络

# 构建TensorRT的Engine
builder.max_workspace_size = 1 << 30  # 设置最大的工作空间大小

# 创建INT8量化的Calibrator对象
calibrator = trt.IInt8Calibrator()

# 设置Builder的INT8量化参数
builder.int8_mode = True  # 启用INT8量化模式
builder.int8_calibrator = calibrator  # 设置Calibrator对象

engine = builder.build_cuda_engine(network)

# 创建TensorRT的执行上下文
context = engine.create_execution_context()

# 创建输入和输出Tensor
input_data = np.random.random(input_shape).astype(np.float32)
output_data = np.empty(output_shape, dtype=np.float32)

# 将输入数据拷贝到GPU内存
input_buf = cuda.mem_alloc(input_data.nbytes)
cuda.memcpy_htod(input_buf, input_data)

# 分配输出Tensor的内存
output_buf = cuda.mem_alloc(output_data.nbytes)

# 执行推理
bindings = [int(input_buf), int(output_buf)]
context.execute_v2(bindings)

# 将输出数据从GPU内存拷贝回主机内存
cuda.memcpy_dtoh(output_data, output_buf)

# 释放资源
context.destroy()
engine.destroy()
network.destroy()
builder.destroy()

C++代码示例：

#include <iostream>
#include <NvInfer.h>

int main()
{
    // 创建TensorRT的Builder对象
    nvinfer1::IBuilder* builder = nvinfer1::createInferBuilder(gLogger);

    // 创建TensorRT的NetworkDefinition对象
    nvinfer1::INetworkDefinition* network = builder->createNetwork();

    // 添加输入层和其他层到网络
    nvinfer1::Dims inputDims{3, 224, 224};
    nvinfer1::ITensor* inputLayer = network->addInput("input", nvinfer1::DataType::kFLOAT, inputDims);
    // 添加其他层到网络

    // 构建TensorRT的Engine
    builder->setMaxWorkspaceSize(1 << 30);  // 设置最大的工作空间大小

    // 创建INT8量化的Calibrator对象
    nvinfer1::IInt8Calibrator* calibrator = new MyInt8Calibrator();

    // 设置Builder的INT8量化参数
    builder->setInt8Mode(true);  // 启用INT8量化模式
    builder->setInt8Calibrator(calibrator);  // 设置Calibrator对象

    nvinfer1::ICudaEngine* engine = builder->buildCudaEngine(*network);

    // 创建TensorRT的执行上下文
    nvinfer1::IExecutionContext* context = engine->createExecutionContext();

    // 创建输入和输出Tensor
    float* input_data = new float[inputDims.d[0] * inputDims.d[1] * inputDims.d[2]];
    // 填充输入数据
    // 创建其他层的输出Tensor

    // 将输入数据拷贝到GPU内存
    cudaMemcpy(input_buf, input_data, inputDims.d[0] * inputDims.d[1] * inputDims.d[2] * sizeof(float), cudaMemcpyHostToDevice);

    // 分配输出Tensor的内存
    float* output_data = new float[outputDims.d[0] * outputDims.d[1] * outputDims.d[2]];
    // 创建其他层的输出Tensor的内存

    // 执行推理
    void* bindings[] = {input_buf, output_buf};
    context->executeV2(bindings);

    // 将输出数据从GPU内存拷贝回主机内存
    cudaMemcpy(output_data, output_buf, outputDims.d[0] * outputDims.d[1] * outputDims.d[2] * sizeof(float), cudaMemcpyDeviceToHost);

    // 释放资源
    delete[] input_data;
    delete[] output_data;
    context->destroy();
    engine->destroy();
    network->destroy();
    builder->destroy();

    return 0;
}

        TensorRT支持模型的量化和推理。它提供了一套工具和接口，可以进行权重和激活的量化，并在优化过程中应用量化技术，以实现高效的深度学习推理。TensorRT还提供了量化感知训练（Quantization-Aware Training）的功能，可以在训练期间考虑量化过程，提高量化后模型的准确性。

        在应用量化技术时，需要权衡量化精度和模型准确性之间的平衡。量化精度越低，模型的准确性可能会有所降低，因此需要根据具体应用场景和要求来选择适当的量化精度。

PS:纯粹为学习分享经验，不参与商用价值运作，若有侵权请及时联系！！！

下一篇内容预告：深度学习模型部署TensorRT加速（五）：TensorRT部署流程及基本使用

猜你喜欢

转载自blog.csdn.net/chenhaogu/article/details/132678883
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022