yolo-inference多后端+多任务+多算法+多精度模型 框架开发记录(cpp版)

已于 2024-10-29 19:26:31 修改
阅读量822 收藏 12
点赞数 7
分类专栏： deep learning # model deployment 文章标签： YOLO 算法
于 2024-06-12 23:53:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/taifyang/article/details/139608823
版权

先贴出github地址，欢迎大家批评指正：https://github.com/taifyang/yolo-inference
不知不觉LZ已经快工作两年了，由于之前的工作内容主要和模型部署相关，想着利用闲暇时间写一些推理方面的经验总结，于是有了这个工程。其实本来也是自己写了玩的，不过已经陆续迭代半年多了，期间也通过借签优秀代码吸收了经验，索性总结一下心得~

1.0 初始版本
1.1 支持多精度模型
1.2 支持tensorrt的cuda前后处理
1.3 支持onnxruntime的int8推理
1.4 onnxruntime推理代码采用cpp风格接口
1.5 采用抽象工厂和单例模式重构代码
1.6 增加cmake编译支持和重构python代码
1.7 增加Linux系统编译支持
2.0 增加yolov8检测器支持
2.1 增加cmake条件编译选项和自动化测试脚本
3.0 增加分类和分割算法支持
3.1 重构代码结构和缺陷修复
3.2 重构代码结构和添加注释
3.3 更新readme和缺陷修复
3.4 增加yolov6, yolov7, yolov9, yolov10检测器支持和缺陷修复
3.5 增加yolov11和pytorch支持和缺陷修复

最初版的接口头文件部分主要如下：

#pragma once


#include <iostream>
#include <fstream>
#include <opencv2/opencv.hpp>

...

enum Device_Type
{
	CPU,
	GPU,
};


class YOLOv5
{
public:
	void infer(const std::string image_path)
	{
		m_image = cv::imread(image_path);
		m_result = m_image.clone();
		pre_process();
		process();
		post_process();
		cv::imwrite("result.jpg", m_result);
		cv::imshow("result", m_result);
		cv::waitKey(0);
	}

	cv::Mat m_image;

	cv::Mat m_result;
	
private:
	virtual void pre_process() = 0;

	virtual void process() = 0;

	virtual void post_process() = 0;
};

该接口类的思路很简单，即一个名为YOLOv5的基类，定义了抽象业务接口如前处理pre_process()、模型推理process()和后处理post_process()需要在派生类中进行具体实现。由基类YOLO根据后端推理框架种类派生出五个子类YOLO_Libtorch 、YOLO_ONNXRuntime、YOLO_OpenCV、YOLO_OpenVINO和YOLO_TensorRT。

#pragma once


#include "yolov5.h"
#include <torch/script.h>
#include <torch/torch.h>


class YOLOv5_Libtorch : public YOLOv5
{	
public:
	YOLOv5_Libtorch(std::string model_path, Device_Type device_type);

	~YOLOv5_Libtorch();

private:
	void pre_process();
		
	void process();

	void post_process();

	torch::DeviceType m_device;

	torch::jit::script::Module module;

	std::vector<torch::jit::IValue> m_inputs;

	torch::jit::IValue m_outputs;
};

调用时初始化传入模型路径和Device_Type，并指定图片路径即可推理，demo如下：

#include "yolov5_libtorch.h"


int main(int argc, char* argv[])
{
	YOLOv5* yolov5 = new YOLOv5_Libtorch("yolov5n_cpu.torchscript", CPU);
	yolov5->infer("bus.jpg");
	return 0;
}

后续扩充了支持不同的模型Model_Type，并使用抽象工厂和单例模式时对外接口在被调用时表现形式更统一：

#pragma once


#include <iostream>
#include <fstream>
#include <opencv2/opencv.hpp>

...

enum Algo_Type
{
	Libtorch,
	ONNXRuntime,
	OpenCV,
	OpenVINO,
	TensorRT,
};

enum Device_Type
{
	CPU,
	GPU,
};

enum Model_Type
{
	FP32,
	FP16,
	INT8,
};


class YOLOv5
{
public:
	virtual void init(const std::string model_path, const Device_Type device_type, Model_Type model_type) = 0;

	void infer(const std::string image_path);

	virtual void release() {};
	
protected:
	virtual void pre_process() = 0;

	virtual void process() = 0;

	virtual void post_process();

	cv::Mat m_image;

	cv::Mat m_result;

	float* m_outputs_host;
};

class  AlgoFactory
{
public:
	typedef std::unique_ptr<YOLOv5>(*CreateFunction)();

	static AlgoFactory& instance();

	void register_algo(const Algo_Type& algo_type, CreateFunction create_function);

	std::unique_ptr<YOLOv5> create(const Algo_Type& algo_type);

private:
	AlgoFactory();

	std::map<Algo_Type, CreateFunction> m_algo_registry;
};

AlgoFactory类中m_algo_registry用来储存算法的唯一全局注册表，register_algo接口用来注册算法，create接口用来返回抽象工厂创建的算法，具体实现如下：

AlgoFactory& AlgoFactory::instance()
{
	static AlgoFactory algo_factory;
	return algo_factory;
}


void AlgoFactory::register_algo(const Algo_Type& algo_type, CreateFunction create_function)
{
	m_algo_registry[algo_type] = create_function;
}


std::unique_ptr<YOLOv5> AlgoFactory::create(const Algo_Type& algo_type)
{
	assert(("algo type not exists!", m_algo_registry.find(algo_type) != m_algo_registry.end()));
	return m_algo_registry[algo_type]();
}


AlgoFactory::AlgoFactory()
{
	register_algo(Algo_Type::Libtorch, []() -> std::unique_ptr<YOLOv5> { return std::make_unique<YOLOv5_Libtorch>(); });
	register_algo(Algo_Type::ONNXRuntime, []() -> std::unique_ptr<YOLOv5> { return std::make_unique<YOLOv5_ONNXRuntime>(); });
	register_algo(Algo_Type::OpenCV, []() -> std::unique_ptr<YOLOv5> { return std::make_unique<YOLOv5_OpenCV>(); });
	register_algo(Algo_Type::OpenVINO, []() -> std::unique_ptr<YOLOv5> { return std::make_unique<YOLOv5_OpenVINO>(); });
	register_algo(Algo_Type::TensorRT, []() -> std::unique_ptr<YOLOv5> { return std::make_unique<YOLOv5_TensorRT>(); });
}

此时调用时需要先创建算法实例，并依次调用init()、infer()和release()接口，demo的表现形式如下：

#include "yolov5.h"


int main(int argc, char* argv[])
{
	std::unique_ptr<YOLOv5> yolov5 = AlgoFactory::instance().create(Algo_Type::Libtorch);
	yolov5->init("yolov5n_cpu_fp32.torchscript", CPU, FP32);
	yolov5->infer("test.mp4");
	yolov5->release();
	return 0;
}

2.x版本中主要增加了对yolov8检测器的支持，接口头文件除了增加Algo_Type枚举类型用来表示不同算法：

enum Algo_Type
{
	YOLOv5,
	YOLOv8,
};

3.x版本主要增加了对分类、分割算法的支持，头文件增加了Task_Type枚举类型，由于维度的扩充将算法注册表替换为二维向量来储存：

#pragma once

#include <iostream>
#include <fstream>
#include <opencv2/opencv.hpp>

enum Backend_Type
{
	Libtorch,
	ONNXRuntime,
	OpenCV,
	OpenVINO,
	TensorRT,
};

enum Task_Type
{
	Classification,
	Detection,
	Segmentation,
};

enum Algo_Type
{
	YOLOv5,
	YOLOv8,
};

enum Device_Type
{
	CPU,
	GPU,
};

enum Model_Type
{
	FP32,
	FP16,
	INT8,
};

class YOLO
{
public:
	virtual ~YOLO() {};	//不加此句会导致虚拟继承内存泄漏

	virtual void init(const Algo_Type algo_type, const Device_Type device_type, const Model_Type model_type, const std::string model_path) = 0;

	void infer(const std::string file_path, char* argv[], bool save_result = true, bool show_result = true);

	virtual void release() {};

protected:
	virtual void pre_process() = 0;

	virtual void process() = 0;

	virtual void post_process() = 0;

	cv::Mat m_image;

	cv::Mat m_result;

	int m_input_width = 640;

	int m_input_height = 640;

	int m_input_numel = 1 * 3 * m_input_width * m_input_height;
};

class  CreateFactory
{
public:
	typedef std::unique_ptr<YOLO>(*CreateFunction)();

	static CreateFactory& instance();

	void register_class(const Backend_Type& backend_type, const Task_Type& task_type, CreateFunction create_function);

	std::unique_ptr<YOLO> create(const Backend_Type& backend_type, const Task_Type& task_type);

private:
	CreateFactory();

	std::vector<std::vector<CreateFunction>> m_create_registry;
};

CreateFactory& CreateFactory::instance()
{
	static CreateFactory create_factory;
	return create_factory;
}

void CreateFactory::register_class(const Backend_Type& backend_type, const Task_Type& task_type, CreateFunction create_function)
{
	m_create_registry[backend_type][task_type] = create_function;
}

std::unique_ptr<YOLO> CreateFactory::create(const Backend_Type& backend_type, const Task_Type& task_type)
{
	if (backend_type >= m_create_registry.size())
	{
		std::cout << "unsupported backend type!" << std::endl;
		std::exit(-1);
	}
	if (task_type >= m_create_registry[task_type].size())
	{
		std::cout << "unsupported task type!" << std::endl;
		std::exit(-1);
	}

	return m_create_registry[backend_type][task_type]();
}

CreateFactory::CreateFactory()
{
	m_create_registry.resize(5, std::vector<CreateFunction>(3));

#ifdef _YOLO_LIBTORCH
	register_class(Backend_Type::Libtorch, Task_Type::Classification, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_Libtorch_Classification>(); });
	register_class(Backend_Type::Libtorch, Task_Type::Detection, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_Libtorch_Detection>(); });
	register_class(Backend_Type::Libtorch, Task_Type::Segmentation, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_Libtorch_Segmentation>(); });
#endif // _YOLO_Libtorch

#ifdef _YOLO_ONNXRUNTIME
	register_class(Backend_Type::ONNXRuntime, Task_Type::Classification, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_ONNXRuntime_Classification>(); });
	register_class(Backend_Type::ONNXRuntime, Task_Type::Detection, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_ONNXRuntime_Detection>(); });
	register_class(Backend_Type::ONNXRuntime, Task_Type::Segmentation, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_ONNXRuntime_Segmentation>(); });
#endif // _YOLO_ONNXRuntime

#ifdef _YOLO_OPENCV
	register_class(Backend_Type::OpenCV, Task_Type::Classification, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_OpenCV_Classification>(); });
	register_class(Backend_Type::OpenCV, Task_Type::Detection, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_OpenCV_Detection>(); });
	register_class(Backend_Type::OpenCV, Task_Type::Segmentation, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_OpenCV_Segmentation>(); });
#endif // _YOLO_OpenCV

#ifdef _YOLO_OPENVINO
	register_class(Backend_Type::OpenVINO, Task_Type::Classification, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_OpenVINO_Classification>(); });
	register_class(Backend_Type::OpenVINO, Task_Type::Detection,[]() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_OpenVINO_Detection>(); });
	register_class(Backend_Type::OpenVINO, Task_Type::Segmentation, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_OpenVINO_Segmentation>(); });
#endif // _YOLO_OpenVINO

#ifdef _YOLO_TENSORRT
	register_class(Backend_Type::TensorRT, Task_Type::Classification, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_TensorRT_Classification>(); });
	register_class(Backend_Type::TensorRT, Task_Type::Detection, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_TensorRT_Detection>(); });
	register_class(Backend_Type::TensorRT, Task_Type::Segmentation, []() -> std::unique_ptr<YOLO> { return std::make_unique<YOLO_TensorRT_Segmentation>(); });
#endif // _YOLO_TensorRT
}

通过基类YOLO根据任务类型派生出三个子类YOLO_Classification、YOLO_Detection ，并由YOLO_Detection 派生出YOLO_Segmentation：

#pragma once

#include "yolo.h"
#include "utils.h"

class YOLO_Classification : virtual public YOLO
{
protected:
	void draw_result(std::string label);

	int class_num = 1000;
};

#pragma once

#include "yolo.h"
#include "utils.h"

class YOLO_Detection : virtual public YOLO
{
protected:
	void LetterBox(cv::Mat& input_image, cv::Mat& output_image, cv::Vec4d& params, cv::Size shape = cv::Size(640, 640), cv::Scalar color = cv::Scalar(114, 114, 114));

	void nms(std::vector<cv::Rect> & boxes, std::vector<float> & scores, float score_threshold, float nms_threshold, std::vector<int> & indices);

	void scale_box(cv::Rect& box, cv::Size size);

	void draw_result(std::string label, cv::Rect box);

	int class_num = 80;

	float score_threshold = 0.2;

	float nms_threshold = 0.5;

	float confidence_threshold = 0.2;

	cv::Vec4d m_params;

	int m_output_numprob;

	int m_output_numbox;

	int m_output_numdet;
};

#pragma once

#include "yolo_detection.h"

//网络输出相关参数
struct OutputSeg
{
	int id;             //结果类别id
	float confidence;   //结果置信度
	cv::Rect box;       //矩形框
	cv::Mat boxMask;    //矩形框内mask，节省内存空间和加快速度
};

//掩膜相关参数
struct MaskParams
{
	int segChannels = 32;
	int segWidth = 160;
	int segHeight = 160;
	int netWidth = 640;
	int netHeight = 640;
	float maskThreshold = 0.5;
	cv::Size srcImgShape;
	cv::Vec4d params;
};

class YOLO_Segmentation : public YOLO_Detection
{
protected:
	void GetMask(const cv::Mat& maskProposals, const cv::Mat& mask_protos, OutputSeg& output, const MaskParams& maskParams);

	void draw_result(std::vector<OutputSeg> result);

	MaskParams m_mask_params;

	int m_output_numseg;
};

另一方面和之前版本类似，由基类YOLO根据后端推理框架种类派生出五个子类YOLO_Libtorch 、YOLO_ONNXRuntime、YOLO_OpenCV、YOLO_OpenVINO和YOLO_TensorRT。最终的具体实现子类需要派生自任务种类的父类和推理框架种类的父类，如下所示：

class YOLO_Libtorch : virtual public YOLO
{	
public:
	void init(const Algo_Type algo_type, const Device_Type device_type, const Model_Type model_type, const std::string model_path);

protected:
	Algo_Type m_algo;

	torch::DeviceType m_device;

	Model_Type m_model;

	torch::jit::script::Module module;

	std::vector<torch::jit::IValue> m_input;

	torch::jit::IValue m_output;
};

class YOLO_Libtorch_Classification : public YOLO_Libtorch, public YOLO_Classification
{
public:
	void init(const Algo_Type algo_type, const Device_Type device_type, const Model_Type model_type, const std::string model_path);

private:
	void pre_process();

	void process();

	void post_process();

	float* m_output_host;
};
目标检测YOLO实战应用案例100讲-基于深度学习的SAR图像舰船目标检测
qq_36130719的博客
12-11 890
旋转边框的由来是目标检测迈向更加精准的关键一步，如图2.1所示，旋转边框比正常的垂直边框包围起来要更加的紧致，包含其他“目标物”的可能性也会比较 低，同时目标框中的背景信息也更加少，可以近乎完全将船舶与背景分开，这点对 于交叠较多排列紧密的船只尤其重要[47]，同时旋转边框所带来的视觉感受是锚框的 长宽高与真实船舶的尺寸相对一致，所得到的舰船的目标检测就会更加的精准，检 测结果以及视觉感受也会更加优秀。
YOLOv8 引入 RepVGG 重参数化模块
走向CTO的路上...
05-21 1297
RepVGG（Rethinking Parameterization for VGG-Style ConvNets）是一种轻量级高效的卷积神经网络架构，旨在改进 VGG 风格网络的性能。它通过重参数化 VGG 网络中的卷积层来实现，而无需改变网络结构。RepVGG 在 ImageNet 等多个图像识别基准数据集上取得了出色的结果，证明了其有效性和实用性。RepVGG 是一种轻量级高效的卷积神经网络架构，在 ImageNet 等多个图像识别基准数据集上取得了出色的结果。
A-YOLOM
whaosoft143ai的博客
10-09 610
尽管它们都比其他模型更快，包括作者的模型，但它们需要在边缘设备上部署三个单独的模型，这意味着将一个检测模型与两个分割模型合并到一个边缘设备上，总共需要9.68M个参数。尽管它们在各自的领域取得了出色的结果，但由于所需特征的分辨率不同，将它们整合到一起面临挑战，分割操作在像素级别进行，而检测任务在一阶段方法中使用网格单元，并在两阶段方法中使用选择性搜索。A-YOLOM(s)具有更复杂的Backbone网络，提供了更强大的性能，但时间开销也更大，特别是在bs=32的情况下。此外，它可以提供大视野的3D信息。
基于 YOLOv8 的多任务融合与端到端交通场景智能感知系统构建
suwuzs的博客
03-03 907
在智能交通蓬勃发展的当下，构建一个能够精准感知交通场景中各类目标的智能系统至关重要。通过将车辆、行人、交通设施等多种目标识别任务进行融合，并打造端到端的系统，可实现对交通场景的全面、实时、高效感知。YOLOv8 作为先进的目标检测算法，在这一过程中发挥着关键作用。
YOLOv8 到 YOLO11：从架构层面深入对比综述
AI工程化、开源分享、文档翻译、代码笔记
02-06 2655
一、YOLO 版本更迭 二、变化 1、输入图像的调整 2、YOLO系列模型架构 YOLOv8 的架构图示例 YOLOv9 的架构图 YOLOv10 的架构图 YOLO11 的架构图 YOLO8 vs 11性能对比
YOLO 多任务支持
m0_37302966的博客
10-14 808
YOLO 多任务支持
YOLOv8 多种任务网络结构详细解析 | 目标检测、实例分割、人体关键点检测、图像分类
秋山丶雪绪的博客
06-01 5012
本文仅根据模型的预测过程，即从输入图像到输出结果（图像预处理、模型推理、后处理），来展现不同任务下的网络结构，OBB 任务暂不包含。
YOLOv8的目标对象的分类，分割，跟踪和姿态估计的多任务检测实践(Netron模型可视化)
深度学习领域优质创作者，优快云博客专家
06-27 7699
熟悉yolov8，多任务检测，分类、分割、姿态估计等
YOLOv8多任务版本A-YOLOM开源！超越YOLOv8和YOLOP
CV_Autobot的博客
10-14 3990
作者|AI视界引擎 编辑| 自动驾驶Daily点击下方卡片，关注“自动驾驶之心”公众号ADAS巨卷干货，即可获取点击进入→自动驾驶之心【目标检测】技术交流群本文只做学术分享，如有侵权，联系删文导读本文作者提出了A-YOLOM，一个专门设计用于多任务的自适应模型，该模型在不需要任何特定的自定义结构或损失函数的情况下运行。高精度、轻量级和实时响应性是实施自动驾驶的三个重要要求。同时考虑所有这...
TensorRT + LLM 多模态推理协同部署：高吞吐 × 精度稳定的系统级方案
最新发布
在信息的熵增中，记录结构、重建秩序。 技术思想者的笔记，系统构建者的注释。
04-12 928
多模态系统正在成为 AI 应用的主流架构，如何将语言大模型（LLM）与视觉模型（如 CLIP、BLIP、SAM、YOLO）协同部署，是落地 AI Agent、VQA 系统、文图检索、场景分析的关键。 > 本文将从工程角度深入讲解如何使用 TensorRT 构建多模型异构部署体系，支持 LLM 与视觉模型协同调度，包括：多后端模型分发、动态任务图管理、显存隔离与上下文共享、异步管线执行、跨模型 Plugin 复用等能力。最终构建一个**具备高性能、可扩展、稳定性的多模态智能引擎
YOLO模型推理优化：提升实时检测效率的关键
YOLO（You Only Look Once）模型是计算机视觉领域的一种高效实时目标检测算法。与传统的目标检测方法不同，YOLO将目标检测任务转化为一个单一的回归问题，通过在图像中直接划分区域，并对每个区域进行分类和边界框...
深入浅出之Ultralytics框架
浩瀚之水的专栏
10-08 2178
Ultralytics框架提供了一系列流行的视觉模型，如YOLO系列（YOLOv5、YOLOv4、YOLOv3等）、EfficientDet、PAN、PP-YOLO等，并配备了相应的训练、评估和推理工具。这些工具和模型使得用户可以轻松地进行计算机视觉任务的开发和部署。
2022-Yolox-inference
06-16
源码！ 源码！源码！ 1.前言说明 ● 此发布版本为静态调用方式，需要.dll .h .lib。 ● 内容包括示例Demo（exe）以及调用库文件（.dll）共两个主要工程。 2.环境说明 在得到trt（.engine）文件之前 1. yolox工程版本：0.3.0 2. 训练环境：Ubuntu18.02 3. torch版本：1.9.1 4. torch2trt版本：0.3.0 5. cuDNN 8.0.4 6. CUDA：11.1.0 7. CUDA Driver Version: 460.91.03 通过yolox 工程自行训练，得到.pth 文件后转成trt(.engine)文件。 这里最重要的一步是自己ubuntu环境中安装tensorrt。自己百度，例如：tensorrt ubuntu 得到trt文件之后 1. CUDA版本：11.0 2. Cudnn版本：cudnn-11.2-windows-x64-v8.1.1.33 3. Nvidia驱动版本：457.49 4. TensorRT版本：TensorRT-7.2.3.4
YOLOv8 多任务项目教程
gitblog_00414的博客
08-22 626
YOLOv8 多任务项目教程 项目地址:https://gitcode.com/gh_mirrors/yo/YOLOv8-multi-task 1. 项目的目录结构及介绍 YOLOv8-multi-task/ ├── configs/ │ ├── default_config.yaml │ └── ... ├── data/ │ ├── annotations/ │ ├── ima...
多任务学习 | YOLOP，一个网络同时完成三大任务
热门推荐
gzq0723的博客
10-13 1万+
关注并星标从此不迷路计算机视觉研究院公众号ID｜ComputerVisionGzq学习群｜扫码在主页获取加入方式paper:https://arxiv.org/abs/2108.1125...
Yolo中的：Rectangular training/inference
qq_52302919的博客
07-18 1377
Yolo中的：Rectangular training/inference 在YOLO中是下采样往往是成整数倍数的，比如YOLOv3中是下采样32倍，长宽也必须是32的倍数，但是由于有些图片并不符合这个标准，所以数据在进入模型前，数据需要resize到416×416大小，也就是我们所说的仿射变换。 这张图片为长方形，我们在将其送入模型前需要将其resize到要求的尺寸，所以我们需要通过补灰padding来变为正方形的图。 但是这个操作会生成过多的冗余信息影响训练效果。Rectangular training
【旭日x3】多任务学习YOLOP
Rex大居
02-10 567
YOLOP
【目标检测】52、YOLOP | 一次就能完成全景驾驶的三大任务
呆呆的猫的博客
09-16 1887
基于上述讨论，提出了 panoptic driving perception network（YOLOP）， 是一个支持多任务学习的全景感知网络，能够同时支持目标检测、可通行区域识别、车道线检测任务。还有一个隐藏的信息：全景驾驶系统虽然有多个任务，但这些任务面对的对象都是有一定的关联的。2、Neck：SPP + FPN，SPP 生成并结合各个不同尺度的特征，FPN 结合各个不同语义尺度的特征，让组合后的特征包含多尺度和多语义层级的信息。训练，验证，测试 分别为 70k，10k，20k。
基于 YOLOR 的统一多任务学习范式
专注计算机视觉全栈知识分享
11-04 472
本文从人类学习的角度分析了图像字幕生成任务所需的语义信息。研究人员分析了不同视觉任务之间的关联性，将多个任务结合在一起进行训练，最大化了所有任务之间的共享语义。此外，他们深入讨论了数据增强技术和优化器模式，以从语义的角度设计训练流程，并减少语义错误的影响。实验结果显示，相比其他多任务模型，本文所提模型更轻量化，并在所有任务上取得了出色的成绩。此外，在多任务联合学习架构下，通过共享语义和学习率，能够使图像字幕生成任务能够在不使用任何预训练模型的情况下达到不错的性能，同时具备良好的可扩展性。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

给算法爸爸上香

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

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

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

打赏作者

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

抵扣说明：

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

余额充值