caffe 模型修改 加密解密

最新推荐文章于 2024-01-12 09:14:50 发布
最新推荐文章于 2024-01-12 09:14:50 发布
阅读量2k 收藏 2
点赞数
分类专栏： caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011808673/article/details/86531828
版权

 encoder:

拥有自己的加密解密过程，下面只是简单实例，如果实际使用应该使用更加复杂的方式进行。

void encoder_conv_model(std::string prototxt, std::string &model_path, std::vector<float> & param) {
		
		caffe::NetParameter netparam;
		caffe::ReadNetParamsFromBinaryFileOrDie(model_path, &netparam);

		int layer_size = netparam.layer_size();
		std::cout << "layer_size = " << layer_size << std::endl;
		caffe::LayerParameter* layerparam = nullptr;
		for (size_t i = 0; i < 2; i++)
		{
			layerparam = netparam.mutable_layer(i);
			std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			for (size_t j = 0;  j < n;  j++)
			{
				const caffe::BlobProto& blob = layerparam->blobs(j);
				printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());
				std::cout << blob.data()[0]<<std::endl;
			}
		}
		
		string model_filename = "model\\encode_test.caffemodel";
		//加密-----------------------------------------------------
		for (size_t i = 0; i < layer_size; i++)
		{
			layerparam = netparam.mutable_layer(i);
			std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			//if (layerparam->type() == "Convolution") {
				for (size_t j = 0; j < n; j++)
				{
					const caffe::BlobProto& blob = layerparam->blobs(j);
					printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());

					caffe::BlobProto * blobs = layerparam->mutable_blobs(j);
					google::protobuf::RepeatedField< float > * data = blobs->mutable_data();
					data[0][0] = blob.data()[0] - 3.5f;
					std::cout << blob.data()[0] << std::endl;
				}
			//}
		}
		caffe::WriteProtoToBinaryFile(netparam, model_filename);
		//加密-----------------------------------------------------

		//google::protobuf::ShutdownProtobufLibrary();
	}

decoder:

 

int CommonCaffe::load_model(string model_definition, string weights, int gpu_id) {
		SetDevice(gpu_id);
		auto load_net= new Net<float>(model_definition, Phase::TEST);//boost::make_shared<Net<float> >(model_definition, Phase::TEST);
		
		caffe::NetParameter netparam;
		caffe::ReadNetParamsFromBinaryFileOrDie(weights, &netparam);
		
		//解密---------------------------------------------------------------------
		int layer_size = netparam.layer_size();
		std::cout << "layer_size = " << layer_size << std::endl;
		caffe::LayerParameter* layerparam = nullptr;
		for (size_t i = 0; i < layer_size; i++)
		{
			layerparam = netparam.mutable_layer(i);
			std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			for (size_t j = 0; j < n; j++)
			{
				const caffe::BlobProto& blob = layerparam->blobs(j);
				printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());

				caffe::BlobProto * blobs = layerparam->mutable_blobs(j);
				google::protobuf::RepeatedField< float > * data = blobs->mutable_data();
				data[0][0] = blob.data()[0] + 3.5f;
				std::cout << blob.data()[0] << std::endl;
			}
		}
		load_net->CopyTrainedLayersFrom(netparam);
}

 

 

#ifndef _SECURITY_H_
#define _SECURITY_H_

//#include <iostream>
//#include <fstream>
//#include <string>
//#include <caffe/proto/caffe.pb.h>
//#include <caffe/caffe.hpp>
//#include <caffe/util/io.hpp>
//#include <google/protobuf/io/coded_stream.h>
//#include <google/protobuf/io/zero_copy_stream_impl.h>
//using google::protobuf::io::FileInputStream;
//using google::protobuf::io::FileOutputStream;
//using google::protobuf::io::ZeroCopyInputStream;
//using google::protobuf::io::CodedInputStream;

namespace security {
	const int change_size = 20;
	const float asisc[change_size] = {3.35f, 3.21f, 0.92f, -2.48f, -1.96f, -3.71f, 5.64f, 8.55f, 6.97f, -7.83f
	-5.67f, -4.96f, -1.54f, 2.56f, 3.68f, 2.64f, -2.45f, 5.63f, 2.72f, 3.95f};
	int getParameterFormCaffeModel(std::string &model_path, std::vector<float> & param)
	{
		caffe::NetParameter netparam;
		std::ifstream caffemodel(model_path, std::ifstream::in | std::ifstream::binary);
		if (&caffemodel == NULL) {
			std::cout << "The ptr of caffemodel is NULL" << std::endl;
			return -1;
		}
		if (!caffemodel.is_open()) {
			std::cout << "Can not open model" << std::endl;
			return -1;
		}
		bool flag = netparam.ParseFromIstream(&caffemodel); //该方法有大小限制，注意
		int layer_size = netparam.layer_size();
		std::cout << "layer_size = " << layer_size << std::endl;
		caffe::LayerParameter* layerparam = nullptr;
		for (size_t i = 0; i < layer_size; i++)
		{
			layerparam = netparam.mutable_layer(i);
			std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			if (n)
			{
				const caffe::BlobProto& blob = layerparam->blobs(0);
				printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());
				for (size_t j = 0; j < blob.data_size(); j++)
				{
					float weight = blob.data()[j];
					std::cout << "weight is:" << weight << std::endl;
					param.push_back(weight);
				}

				const caffe::BlobProto& blob_b = layerparam->blobs(1);
				printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob_b.data_size());
				for (size_t j = 0; j < blob_b.data_size(); j++)
				{
					float bias = blob_b.data()[j];
					std::cout << "bias is:" << bias << std::endl;
					param.push_back(bias);
				}
			}
		}
		caffemodel.close();
		google::protobuf::ShutdownProtobufLibrary();
		return 0;
	}
	caffe::NetParameter encoder_model(std::string model_file, std::string save_model_file) {
		caffe::NetParameter netparam;
		caffe::ReadNetParamsFromBinaryFileOrDie(model_file, &netparam);
		int layer_size = netparam.layer_size();
		std::cout << "layer_size = " << layer_size << std::endl;
		caffe::LayerParameter* layerparam = nullptr;
		/*for (size_t i = 0; i < 2; i++)
		{
			layerparam = netparam.mutable_layer(i);
			std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			for (size_t j = 0; j < n; j++)
			{
				const caffe::BlobProto& blob = layerparam->blobs(j);
				printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());
				std::cout << blob.data()[0] << std::endl;
			}
		}*/

		//加密-----------------------------------------------------
		for (size_t i = 0; i < layer_size; i++)
		{
			layerparam = netparam.mutable_layer(i);
			std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			for (size_t j = 0; j < n; j++)
			{
				const caffe::BlobProto& blob = layerparam->blobs(j);
				//printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());
				caffe::BlobProto * blobs = layerparam->mutable_blobs(j);
				google::protobuf::RepeatedField< float > * data = blobs->mutable_data();
				if (data[0].size() > change_size) {
					for (size_t k = 0; k < change_size; k++)
					{
						data[0][k] = blob.data()[k] - asisc[k];
					}
				}
				else {
					data[0][0] = blob.data()[0] - asisc[0];
				}
				//std::cout << blob.data()[0] << std::endl;
			}
		}
		caffe::WriteProtoToBinaryFile(netparam, save_model_file);
		//加密-----------------------------------------------------
		return netparam;
	}
	void decoder_model(caffe::NetParameter &netparam, std::string weights) {
		//caffe::NetParameter netparam;
		caffe::ReadNetParamsFromBinaryFileOrDie(weights, &netparam);
		//解密---------------------------------------------------------------------
		int layer_size = netparam.layer_size();
		//std::cout << "layer_size = " << layer_size << std::endl;
		caffe::LayerParameter* layerparam = nullptr;
		for (size_t i = 0; i < layer_size; i++)
		{
			layerparam = netparam.mutable_layer(i);
			//std::cout << "layer type:" << layerparam->type() << std::endl;
			int n = layerparam->mutable_blobs()->size();
			for (size_t j = 0; j < n; j++)
			{
				const caffe::BlobProto& blob = layerparam->blobs(j);
				//printf("%s layer: %s weight(%d)", layerparam->type().c_str(), layerparam->name().c_str(), blob.data_size());

				caffe::BlobProto * blobs = layerparam->mutable_blobs(j);
				google::protobuf::RepeatedField< float > * data = blobs->mutable_data();

				if (data[0].size() > change_size) {
					for (size_t k = 0; k < change_size; k++)
					{
						data[0][k] = blob.data()[k] + asisc[k];
					}
				}
				else {
					data[0][0] = blob.data()[0] + asisc[0];
				}
				//data[0][0] = blob.data()[0] + 3.5f;
				//std::cout << blob.data()[0] << std::endl;
			}
		}
		//解密---------------------------------------------------------------------
	}
}

#endif // _UTIL_H_

 

NineDays66
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
内存中加解密Caffe模型
08-23
1、模型使用rc6算法加密 2、模型解密 3、在内存中加载网络，不生成临时文件
深度学习：caffe模型加密
微风❤水墨
01-11 3139
最近工作中需要对caffe的prototxt和model文件进行加密操作。翻看github，浏览到了一份不错的code。 进过调试，主体代码是没有问题。 1：自己需要的改动是使用二进制方式读取model。 2：还需要加入一下自己的明文，防止他人使用相同代码进行解密。 fprototxt.open(prototxtFile); fmodel.open(caffemodelFile); ...
caffe模型加密算法实现
qq_14950689的博客
08-07 1453
因为要对公司的caffe模型进行加密，但是之前没有做过加密算法，不知道从何入手。找到两篇比较有价值文章作参考。 一、最简单的异或逻辑加密 https://github.com/HaoLiuHust/caffe_model_encrypt 因为之前改过一些caffe的代码，所以还算比较容易。唯一的坑是之前训练的模型保存为HDF5格式，但是这里要求的是二进制。所以需要修改solver.protxt 继...
OpenPose安装过程中遇到的问题
H4cker的博客
02-27 4395
OpenPose安装过程中遇到的问题 操作系统：Ubuntu 18.04 LTS 64位 已安装的CUDA版本：CUDA9.0，安装教程https://blog.csdn.net/blgpb/article/details/82048478 OpenPose版本：OpenPose V1.4.0(https://github.com/CMU-Perceptual-Computing-Lab/op...
剖析Caffe源码之Net---NetParameter参数
weixin_42730667的博客
10-24 1114
前面几篇文章主要分析了Caffe中的Blob和Layer源码，了解到了Caffe中的参数数据结构文件caffe.proto，掌握了各个Layer是如何注册到Caffe中，下面将分析Net层。 在分析Net层之前首先要了解Net层入参NetParameter #1NetParameter NetParameter参数数据结构同一定义在caffe.proto文件中，其结构总体如下： ...
caffe 学习笔记之NetParameter
learning notes
06-22 7100
caffe层的类型图有： caffe Net在proto文件中的定义为：message NetParameter { optional string name = 1; //net的名字 // DEPRECATED. See InputParameter. The input blobs to the network. repeated string input = 3;
caffe模型加解密以及内存加载.zip
09-10
本文件包括caffe框架 从buffer中读取模型，以及对模型的加解密处理，很好的解决了模型安全性问题
异或加密caffe模型工具/代码
06-26
异或加密caffe模型的C++代码，很容易可以扩展使用其他加密算法，可以用于部署时保护模型的安全
python接口调用已训练好的caffe模型测试分类方法
09-18
今天小编就为大家分享一篇python接口调用已训练好的caffe模型测试分类方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
opencv dnn模块调用caffe模型
07-15
利用opencv dnn模块调用caffe 模型，并给出一个训练好的模型（cifar10集合上的image classification模型），cmakelists.txt要设置CMAKE_MODULE_PATH指向opencv#3.3.1的头文件和库的路径
文件、网络模型加密解密
最新发布
wd1603926823的专栏
01-12 444
为了更安全地使用模型，所以必须加密解密。
密码算法原理与实现：AES加密算法
北观止的博客
10-12 4778
基础部分概述： 本节目的：这一章作为AES算法的基础部分，目的主要是整理下密码学中AES加密与解密的相关知识点，并把它们分享出来。 阅读方法：希望大家在浏览完本章文章后可以自己去实现一下，相信一定会对你的编程技术有所提高。(附件中提供参考代码) 具备基础： (1)熟练掌握C语言 (2)相关数学知识 学习环境：任意C语言开发环境，一个正确的AES算法程序(方便调试，验证程序结果)
caffe（一）Parameter解析
更木的博客
02-04 476
1.proto梳理 ParamSpec message ParamSpec{ // The names of the parameter blobs -- useful for sharing parameters among // layers, but never required otherwise. To share a parameter between tw
Caffe到底训练出了个什么东西：caffemodel解析
zzou清月灵兮的博客
08-27 7830
Caffe中，数据的读取、运算、存储都是采用Google Protocol Buffer来进行的，所以首先来较为详细的介绍下Protocol Buffer(PB)。 PB是一种轻便、高效的结构化数据存储格式，可以用于结构化数据串行化，很适合做数据存储或 RPC 数据交换格式。它可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。是一种效率和兼容性都很优秀的二进制数
【1】caffe调参中的batch_size和iter_size
yeler082的博客
10-22 5236
在caffe参数配置文件当中遇到这么一段： net: "models/h2_train.prototxt" #模型训练网络配置文件 base_lr: 1e-6 #基础学习率 lr_policy: "step" #学习率变化策略 gamma: 0.1 #grama值，用于学习率变化 iter_size: 10 stepsize: 10000 #用于学习率调整的步长，与lr...
【Caffe】caffe框架讲解，解析修改caffemodel与prototxt
Hali_Botebie的博客
05-19 4367
背景 pytorch转onnx后，onnx转tensorRT 各种问题。主要是TX2安装的tensorRT版本较低，也没有去刷机升级的想法。 尝试了 onnx-tensorRT 以及torch2trt 项目，完全没心思搞了。 还是按照标准流程 转caffe 然后部署到tensorRT ，TX2也有官方支持的caffe的脚本。 参考 1、Pytorch模型转Caffe模型小记 https://zhuanlan.zhihu.com/p/352750171 得到了pytorch2caffe工具： github.c
剖析Caffe源码之Net（上）---NetParameter参数
weixin_42730667的博客
12-01 318
前面几篇文章主要分析了Caffe中的Blob和Layer源码，了解到了Caffe中的参数数据结构文件caffe.proto，掌握了各个Layer是如何注册到Caffe中，下面将分析Net层。 在分析Net层之前首先要了解Net层入参NetParameter NetParameter NetParameter参数数据结构同一定义在caffe.proto文件中，其结构总体如下： messag...
【YOLOV5从开发到部署实战】九、YOLO训练出的模型权重加解密方法
年少的勇气已经用完，剩下的就是三思而后行
05-03 3204
我们以官方YOLOv5s.pt代码为例，对模型训练的权重进行加密，加密后的结果为： 注意key.txt保存的是解密用的密钥，一定要保存好！！ 加密代码 from cryptography.fernet import Fernet # 密钥生成后自行以安全方式保存 key = Fernet.generate_key() f = Fernet(key) # 保存解码密钥 file = open('./key.txt','w') file.write(str(key.decode('utf-8')))
caffe源码 Net的Init()及Netparameter 详解
小小码农的博客
05-20 3121
Net完成的工作主要是：根据咱们写的prototxt网络结构文件，完成层之间的连接和初始化。这里先介绍其数据结构Netparameter ，再详解源码。关于protobuf的前置知识可以参考之前的博文。message NetParameter { optional string name = 1; // consider giving the network a name网络名 // DE...
pytorch模型转caffe模型
07-28
你可以使用一些工具和库来将PyTorch模型转换为Caffe模型。以下是一种常用的方法： 1. 首先，你需要安装并导入PyTorch和Caffe的Python库。 2. 加载你的PyTorch模型，并将其转换为Caffe模型的中间表示。你可以使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

NineDays66

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

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

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

打赏作者

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

抵扣说明：

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

余额充值