-牧野-

【撸码caffe 三】 caffe.cpp

caffe.cpp文件完成对网络模型以及模型配置参数的读入和提取，提供了网络模型训练的入口函数train和对模型的测试入口函数test。文件中使用了很多gflags和glog指令，gflags是google的一个开源的处理命令行参数的库，glog是一个有效的日志记录工具。

补充一点CUDA中查询GPU设备属性的知识：

CUDA C中的cudaGetDeviceProperties函数可以很方便的获取到设备的信息，caffe.cpp中就使用到了这个函数查询设备信息，函数原型是：

[cpp]  view plain 
      copy 
     
 print ? 
    
 cudaError_t CUDARTAPI cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device);  

第二个参数device是从0开始的设备的编号。

第一个参数prop指向的是一个cudaDeviceProp类型的结构。cudaDeviceProp结构中包含了设备的相关属性，下图是其中的几个属性信息：

部分属性信息的相关说明如下：

caffe.cpp文件注释：

#ifdef WITH_PYTHON_LAYER
#include "boost/python.hpp"
namespace bp = boost::python;
#endif

#include 
#include 

#include 
#include 
#include 
#include 

#include "boost/algorithm/string.hpp"
#include "caffe/caffe.hpp"
#include "caffe/util/signal_handler.h"

using caffe::Blob;
using caffe::Caffe;
using caffe::Net;
using caffe::Layer;
using caffe::Solver;
using caffe::shared_ptr;
using caffe::string;
using caffe::Timer;
using caffe::vector;
using std::ostringstream;

/**********************************************************************
DEFINE_string/int32 是gflags（google的一个开源的处理命令行参数的库）中的宏定义
作用是获取命令行中传入的配置的参数值，它的调用格式是（name，val，txt），其中name
是命令行中的配置项，val是配置项的值，txt是描述信息，如果命令行中没有配置变量的值，
则使用DEFINE中的默认值
**********************************************************************/
DEFINE_string(gpu, "",
	"Optional; run in GPU mode on given device IDs separated by ','."
	"Use '-gpu all' to run on all available GPUs. The effective training "
	"batch size is multiplied by the number of devices.");
DEFINE_string(solver, "",
	"The solver definition protocol buffer text file.");
DEFINE_string(model, "",
	"The model definition protocol buffer text file.");
DEFINE_string(phase, "",
	"Optional; network phase (TRAIN or TEST). Only used for 'time'.");
DEFINE_int32(level, 0,
	"Optional; network level.");
DEFINE_string(stage, "",
	"Optional; network stages (not to be confused with phase), "
	"separated by ','.");
DEFINE_string(snapshot, "",
	"Optional; the snapshot solver state to resume training.");
DEFINE_string(weights, "",
	"Optional; the pretrained weights to initialize finetuning, "
	"separated by ','. Cannot be set simultaneously with snapshot.");
DEFINE_int32(iterations, 50,
	"The number of iterations to run.");
DEFINE_string(sigint_effect, "stop",
	"Optional; action to take when a SIGINT signal is received: "
	"snapshot, stop or none.");
DEFINE_string(sighup_effect, "snapshot",
	"Optional; action to take when a SIGHUP signal is received: "
	"snapshot, stop or none.");

// A simple registry for caffe commands.
/*声明一个BrewFunction函数指针类型，可以用它来定义一个函数指针
在main函数中通过这个函数指针调用相应的train或test函数
*/
typedef int(*BrewFunction)();
typedef std::map BrewMap;
BrewMap g_brew_map;

//在C++宏定义中， \的作用是把内容分行显示；   #的作用是把其后的内容转换成字符串
#define RegisterBrewFunction(func) \
namespace {
\
class __Registerer_##func{ \
public: /* NOLINT */ \
	__Registerer_##func() {
	\
	g_brew_map[#func] = &func; \
	} \
}; \
__Registerer_##func g_registerer_##func; \
}

/**********************************************************************
在caffe中，BrewFunction作为GetBrewFunction()函数的返回类型，可以是train(),
test(),device_query(),time()这4个函数指针的其中一个，通过传入的name，指向对应
的函数，在train(),test()函数中，可以调用solver类的函数，从而进入到net，进入到网络
中的每一层，运行整个caffe程序
***********************************************************************/
static BrewFunction GetBrewFunction(const caffe::string& name) {
	if (g_brew_map.count(name)) {   // 判断传入的name是不是train，test，device_query或time中的一种
		return g_brew_map[name];
	}
	else {   //对于其他传入值，打印出错误信息---不含有对应的操作
		LOG(ERROR) << "Available caffe actions:";
		for (BrewMap::iterator it = g_brew_map.begin();
			it != g_brew_map.end(); ++it) {
			LOG(ERROR) << "\t" << it->first;
		}
		LOG(FATAL) << "Unknown action: " << name;
		return NULL;  // not reachable, just to suppress old compiler warnings.
	}
}

// Parse GPU ids or use all available devices
//获取可用的gpu设备
static void get_gpus(vector* gpus) {
	if (FLAGS_gpu == "all") {
		int count = 0;
#ifndef CPU_ONLY
		CUDA_CHECK(cudaGetDeviceCount(&count));
#else
		NO_GPU;
#endif
		for (int i = 0; i < count; ++i) {
			gpus->push_back(i);
		}
	}
	else if (FLAGS_gpu.size()) {
		vector strings;
		boost::split(strings, FLAGS_gpu, boost::is_any_of(","));
		for (int i = 0; i < strings.size(); ++i) {
			gpus->push_back(boost::lexical_cast(strings[i]));
		}
	}
	else {
		CHECK_EQ(gpus->size(), 0);
	}
}

// Parse phase from flags
//返回flags阶段，是TRAIN还是TEST，用于进一步分析
caffe::Phase get_phase_from_flags(caffe::Phase default_value) {
	if (FLAGS_phase == "")
		return default_value;
	if (FLAGS_phase == "TRAIN")
		return caffe::TRAIN;
	if (FLAGS_phase == "TEST")
		return caffe::TEST;
	LOG(FATAL) << "phase must be \"TRAIN\" or \"TEST\"";
	return caffe::TRAIN;  // Avoid warning
}

// Parse stages from flags
vector get_stages_from_flags() {
	vector stages;
	boost::split(stages, FLAGS_stage, boost::is_any_of(","));
	return stages;
}

// caffe commands to call by
//     caffe  
//
// To add a command, define a function "int command()" and register it with
// RegisterBrewFunction(action);

// Device Query: show diagnostic information for a GPU device.
//查询GPU设备信息
int device_query() {
	LOG(INFO) << "Querying GPUs " << FLAGS_gpu;
	vector gpus;
	get_gpus(&gpus);
	for (int i = 0; i < gpus.size(); ++i) {
		caffe::Caffe::SetDevice(gpus[i]);
		caffe::Caffe::DeviceQuery();
	}
	return 0;
}
RegisterBrewFunction(device_query);

// Load the weights from the specified caffemodel(s) into the train and
// test nets.
//赋值Layers
void CopyLayers(caffe::Solver* solver, const std::string& model_list) {
	std::vector model_names;
	boost::split(model_names, model_list, boost::is_any_of(","));
	for (int i = 0; i < model_names.size(); ++i) {
		LOG(INFO) << "Finetuning from " << model_names[i];
		solver->net()->CopyTrainedLayersFrom(model_names[i]);
		for (int j = 0; j < solver->test_nets().size(); ++j) {
			solver->test_nets()[j]->CopyTrainedLayersFrom(model_names[i]);
		}
	}
}

// Translate the signal effect the user specified on the command-line to the
// corresponding enumeration.
//将交互端传来的string类型的标志转换成枚举类型的变量
caffe::SolverAction::Enum GetRequestedAction(
	const std::string& flag_value) {
	if (flag_value == "stop") {
		return caffe::SolverAction::STOP;
	}
	if (flag_value == "snapshot") {
		return caffe::SolverAction::SNAPSHOT;
	}
	if (flag_value == "none") {
		return caffe::SolverAction::NONE;
	}
	LOG(FATAL) << "Invalid signal effect \"" << flag_value << "\" was specified";
	return caffe::SolverAction::NONE;
}

// Train / Finetune a model.
//trian函数功能是对一个网络模型进行训练，对模型参数进行调优
int train() {
	//CHECK_GT是一个宏定义，用来检查传入的参数中“--solver=”后边是否为空，若为空，
	//则报错并输出错误信息，但此处并没有对文件路径合法性检查
	CHECK_GT(FLAGS_solver.size(), 0) << "Need a solver definition to train.";
	//检查命令行中输入的 --snapshot和--weights信息，这两者可以不设置或只设置其一
	CHECK(!FLAGS_snapshot.size() || !FLAGS_weights.size())
		<< "Give a snapshot to resume training or weights to finetune "
		"but not both.";
	vector stages = get_stages_from_flags();

	/********************************************************************
	实例化SolverParameter类，该类报错了solver参数和网络参数的优化规则，SolverParameter是
	通过Google ProtocolBuffer自动生成的一个类， 在SharedCtor函数里对网络的各个参数进行了初始化设置
	********************************************************************/
	caffe::SolverParameter solver_param;
	//从传入的slover文件读入网络的各个参数并传给solver_param对象
	caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param);

	//设置训练状态
	solver_param.mutable_train_state()->set_level(FLAGS_level);
	for (int i = 0; i < stages.size(); i++) {
		solver_param.mutable_train_state()->add_stage(stages[i]);
	}

	// If the gpus flag is not provided, allow the mode and device to be set
	// in the solver prototxt.
	//根据命令参数 -gpu或者solver.prototxt中提供的GPU配置信息设置GPU
	if (FLAGS_gpu.size() == 0
		&& solver_param.solver_mode() == caffe::SolverParameter_SolverMode_GPU) {
		if (solver_param.has_device_id()) {
			FLAGS_gpu = "" +
				boost::lexical_cast(solver_param.device_id());
		}
		else {  // Set default GPU if unspecified
			FLAGS_gpu = "" + boost::lexical_cast(0);
		}
	}

	vector gpus;   //GPU编号
	get_gpus(&gpus);   //获取可用的GPU
	if (gpus.size() == 0) {   //如果没有可用的GPU，则设置运行模式为GPU
		LOG(INFO) << "Use CPU.";
		Caffe::set_mode(Caffe::CPU);
	}
	else {
		//若存在多个GPU，则使用多个GPU一起工作
		ostringstream s;
		for (int i = 0; i < gpus.size(); ++i) {
			s << (i ? ", " : "") << gpus[i];
		}
		LOG(INFO) << "Using GPUs " << s.str();
#ifndef CPU_ONLY
		cudaDeviceProp device_prop;
		for (int i = 0; i < gpus.size(); ++i) {
			//cudaGetDeviceProperties函数用于获取设备的信息
			cudaGetDeviceProperties(&device_prop, gpus[i]);
			//输出设备的型号（名称）
			LOG(INFO) << "GPU " << gpus[i] << ": " << device_prop.name;
		}
#endif
		//GPU设置
		solver_param.set_device_id(gpus[0]);
		Caffe::SetDevice(gpus[0]);
		Caffe::set_mode(Caffe::GPU);
		Caffe::set_solver_count(gpus.size());
	}

	/******************************************************************
	括号内的两个函数，从最右边的开始执行，将 “stop”“snapshot”“none”
	转换成标准信号，即解析。
	函数执行结果是将SIGINT_action对应STOP， SIGHUP_action对应SNAPSHOT
	******************************************************************/
	caffe::SignalHandler signal_handler(
		GetRequestedAction(FLAGS_sigint_effect),
		GetRequestedAction(FLAGS_sighup_effect));
	//通过智能指针创建solver指针，指向caffe::Solver对象
	shared_ptr >
		solver(caffe::SolverRegistry::CreateSolver(solver_param));

	solver->SetActionFunction(signal_handler.GetActionFunction());

	/*******************************************************************************
	判断用户是否定义了snapshot或者weights这两个参数中的一个，如果定义了则需要通过
	Solver提供的接口从snapshot或者weights文件中去读取已经训练好的网络的参数，继续训练
	********************************************************************************/
	if (FLAGS_snapshot.size()) {
		//打印信息，从上一个中断的训练结果文件继续训练
		LOG(INFO) << "Resuming from " << FLAGS_snapshot;
		//读入sanpshot文件内容
		solver->Restore(FLAGS_snapshot.c_str());
	}
	else if (FLAGS_weights.size()) {
		CopyLayers(solver.get(), FLAGS_weights);
	}

	//如果有不止一个GPU，用线程并行优化网络
	if (gpus.size() > 1) {
		caffe::P2PSync sync(solver, NULL, solver->param());
		sync.Run(gpus);
	}
	else {
		LOG(INFO) << "Starting Optimization";
		solver->Solve();   //执行网络模型优化，跳到solver文件执行
	}
	LOG(INFO) << "Optimization Done.";
	return 0;
}
RegisterBrewFunction(train);


//test时间对网络模型的测试和评估
// Test: score a model.
int test() {
	//判断命令行参数里是否传入网络模型
	CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to score.";
	//判断命令行参数里是否传入了训练好的模型参数文件，后缀为caffemodel
	CHECK_GT(FLAGS_weights.size(), 0) << "Need model weights to score.";
	vector stages = get_stages_from_flags();

	// Set device id and mode
	vector gpus;
	get_gpus(&gpus);      //查询GPU设备信息，无可用则设置为运行模式为CPU
	if (gpus.size() != 0) {
		LOG(INFO) << "Use GPU with device ID " << gpus[0];
#ifndef CPU_ONLY
		cudaDeviceProp device_prop;
		cudaGetDeviceProperties(&device_prop, gpus[0]);
		LOG(INFO) << "GPU device name: " << device_prop.name;
#endif
		Caffe::SetDevice(gpus[0]);
		Caffe::set_mode(Caffe::GPU);
	}
	else {
		LOG(INFO) << "Use CPU.";
		Caffe::set_mode(Caffe::CPU);
	}
	// Instantiate the caffe net.
	//创建一个网络模型对象
	Net caffe_net(FLAGS_model, caffe::TEST, FLAGS_level, &stages);
	caffe_net.CopyTrainedLayersFrom(FLAGS_weights);  //加载训练好的模型文件
	LOG(INFO) << "Running for " << FLAGS_iterations << " iterations.";

	vector test_score_output_id;
	vector test_score;
	float loss = 0;
	for (int i = 0; i < FLAGS_iterations; ++i) {     //FLAGS_iterations是配置的测试迭代次数
		float iter_loss;
		const vector*>& result =
			caffe_net.Forward(&iter_loss);     //把测试数据流在网络中做前向传播
		loss += iter_loss;      //累加每次的损失
		int idx = 0;
		for (int j = 0; j < result.size(); ++j) {
			const float* result_vec = result[j]->cpu_data();
			for (int k = 0; k < result[j]->count(); ++k, ++idx) {
				const float score = result_vec[k];
				if (i == 0) {
					test_score.push_back(score);
					test_score_output_id.push_back(j);
				}
				else {
					test_score[idx] += score;
				}
				const std::string& output_name = caffe_net.blob_names()[
					caffe_net.output_blob_indices()[j]];
					//输出迭代的accuracy与loss信息
					LOG(INFO) << "Batch " << i << ", " << output_name << " = " << score;
			}
		}
	}
	loss /= FLAGS_iterations;  // 计算平均损失并打印
	LOG(INFO) << "Loss: " << loss;
	for (int i = 0; i < test_score.size(); ++i) {
		const std::string& output_name = caffe_net.blob_names()[
			caffe_net.output_blob_indices()[test_score_output_id[i]]];
			const float loss_weight = caffe_net.blob_loss_weights()[
				caffe_net.output_blob_indices()[test_score_output_id[i]]];
				std::ostringstream loss_msg_stream;
				const float mean_score = test_score[i] / FLAGS_iterations;
				if (loss_weight) {
					loss_msg_stream << " (* " << loss_weight
						<< " = " << loss_weight * mean_score << " loss)";
				}
				LOG(INFO) << output_name << " = " << mean_score << loss_msg_stream.str();
	}

	return 0;
}
RegisterBrewFunction(test);


//test函数用于测试网络模型的执行时间 
// Time: benchmark the execution time of a model.
int time() {
	CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to time.";
	caffe::Phase phase = get_phase_from_flags(caffe::TRAIN);
	vector stages = get_stages_from_flags();

	// Set device id and mode
	vector gpus;
	get_gpus(&gpus);
	if (gpus.size() != 0) {
		LOG(INFO) << "Use GPU with device ID " << gpus[0];
		Caffe::SetDevice(gpus[0]);
		Caffe::set_mode(Caffe::GPU);
	}
	else {
		LOG(INFO) << "Use CPU.";
		Caffe::set_mode(Caffe::CPU);
	}

	//创建网络模型对象
	// Instantiate the caffe net.
	Net caffe_net(FLAGS_model, phase, FLAGS_level, &stages);

	// Do a clean forward and backward pass, so that memory allocation are done
	// and future iterations will be more stable.
	LOG(INFO) << "Performing Forward";
	// Note that for the speed benchmark, we will assume that the network does
	// not take any input blobs.
	float initial_loss;
	caffe_net.Forward(&initial_loss);   //执行一遍前向传播
	LOG(INFO) << "Initial loss: " << initial_loss;
	LOG(INFO) << "Performing Backward";
	caffe_net.Backward();   //执行反向传播

	const vector > >& layers = caffe_net.layers();
	const vector*> >& bottom_vecs = caffe_net.bottom_vecs();
	const vector*> >& top_vecs = caffe_net.top_vecs();
	const vector >& bottom_need_backward =
		caffe_net.bottom_need_backward();
	LOG(INFO) << "*** Benchmark begins ***";
	LOG(INFO) << "Testing for " << FLAGS_iterations << " iterations.";
	Timer total_timer;
	total_timer.Start();
	Timer forward_timer;
	Timer backward_timer;
	Timer timer;
	std::vector forward_time_per_layer(layers.size(), 0.0);
	std::vector backward_time_per_layer(layers.size(), 0.0);
	double forward_time = 0.0;
	double backward_time = 0.0;
	for (int j = 0; j < FLAGS_iterations; ++j) {
		Timer iter_timer;
		iter_timer.Start();
		forward_timer.Start();
		for (int i = 0; i < layers.size(); ++i) {
			timer.Start();
			layers[i]->Forward(bottom_vecs[i], top_vecs[i]);
			forward_time_per_layer[i] += timer.MicroSeconds();   //累加前向传播中每层网络耗时
		}
		forward_time += forward_timer.MicroSeconds();
		backward_timer.Start();
		for (int i = layers.size() - 1; i >= 0; --i) {
			timer.Start();
			layers[i]->Backward(top_vecs[i], bottom_need_backward[i],
				bottom_vecs[i]);
			backward_time_per_layer[i] += timer.MicroSeconds();  //累加反向传播中每次网络耗时
		}
		backward_time += backward_timer.MicroSeconds();
		LOG(INFO) << "Iteration: " << j + 1 << " forward-backward time: "
			<< iter_timer.MilliSeconds() << " ms.";
	}
	LOG(INFO) << "Average time per layer: ";
	for (int i = 0; i < layers.size(); ++i) {    //统计每层网络的平均耗时
		const caffe::string& layername = layers[i]->layer_param().name();
		LOG(INFO) << std::setfill(' ') << std::setw(10) << layername <<
			"\tforward: " << forward_time_per_layer[i] / 1000 /
			FLAGS_iterations << " ms.";
		LOG(INFO) << std::setfill(' ') << std::setw(10) << layername <<
			"\tbackward: " << backward_time_per_layer[i] / 1000 /
			FLAGS_iterations << " ms.";
	}
	total_timer.Stop();

	//打印总的前向传播和反向传播平均耗时以及训练流程平均耗时
	LOG(INFO) << "Average Forward pass: " << forward_time / 1000 /
		FLAGS_iterations << " ms.";
	LOG(INFO) << "Average Backward pass: " << backward_time / 1000 /
		FLAGS_iterations << " ms.";
	LOG(INFO) << "Average Forward-Backward: " << total_timer.MilliSeconds() /
		FLAGS_iterations << " ms.";
	LOG(INFO) << "Total Time: " << total_timer.MilliSeconds() << " ms.";
	LOG(INFO) << "*** Benchmark ends ***";
	return 0;
}
RegisterBrewFunction(time);

int main(int argc, char** argv) {
	// Print output to stderr (while still logging).
	FLAGS_alsologtostderr = 1;   //输出打印信息

	/************************************************************************
	AS_STRING(CAFFE_VERSION)是一个宏定义，把形参字符串化，相当于”CAFFE_VERSION“
	SetVersinoString函数用于设置版本号，目前应该是一个保留接口，并没有实际用处，这里
	传入的是“CAFFE_VERSION”,也不是具体的版本号
	*************************************************************************/
	// Set version
	gflags::SetVersionString(AS_STRING(CAFFE_VERSION));

	/***************************************************************************
	程序使用信息，说明程序的简单使用方式，如果输入的参数不符号要求，会在之后调用
	函数ShowUsageWithFlagsRestric输出这些信息，gflags是google的一个开源的处理命令行
	参数的库
	***************************************************************************/
	// Usage message.
	gflags::SetUsageMessage("command line brew\n"
		"usage: caffe  \n\n"
		"commands:\n"
		"  train           train or finetune a model\n"
		"  test            score a model\n"
		"  device_query    show GPU diagnostic information\n"
		"  time            benchmark model execution time");

	/****************************************************************************
	初始化flags和logging， argv[0]是本程序exe的完整路径，函数内部会把argc的值减去1，
	由3变成了2（2是实际输入的变量个数）
	****************************************************************************/
	// Run tool or show usage.
	caffe::GlobalInit(&argc, &argv);
	if (argc == 2) {
#ifdef WITH_PYTHON_LAYER
		try {
#endif
			//根据argv[1]（这里是train）的配置，返回train或其他3个函数的指针并执行对应函数
			//一共可以有4个不同的参数，其他3个分别是 train，device_query和time
			return GetBrewFunction(caffe::string(argv[1]))();
#ifdef WITH_PYTHON_LAYER
		}
		catch (bp::error_already_set) {
			PyErr_Print();
			return 1;
		}
#endif
	}
	else {
		gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/caffe");
	}
}

深度学习框架人工智能操作系统训练&前向推理 PyTorch Tensorflow MindSpore caffe 张量加速引擎TBE 深度学习编译器多面体 polyhedral AI集群框架 EwenWanW 深度学习人工智能 pytorch 深度学习编译器
深度学习框架人工智能操作系统训练&前向推理深度学习框架发展到今天，目前在架构上大体已经基本上成熟并且逐渐趋同。无论是国外的Tensorflow、PyTorch，亦或是国内最近开源的MegEngine、MindSpore，目前基本上都是支持EagerMode和GraphMode两种模式。AI嵌入式框架OneFlow&清华计图Jittor&华为深度学习框架MindSpore&旷视深度学习框架MegEn
Caffeine 与 Guava Cache 雨季里的向日葵 java
一、概要1.1背景在项目开发中，为提升系统性能，减少IO开销，本地缓存是必不可少的。最常见的本地缓存是Guava和Caffeine，Caffeine是基于GoogleGuavaCache设计经验改进的结果，相较于Guava在性能和命中率上更具有效率。1.2应用场景愿意消耗一些内存空间来提升速度预料到某些键会被多次查询缓存中存放的数据总量不会超出内存容量二、GuavaCache2.1GuavaCac
OSError: [WinError 126] 找不到指定的模块---caffe2_detectron_ops_gpu.dll 努力的小柚 python运行问题 python pytorch
代码复现记录：问题：OSError:[WinError126]找不到指定的模块。Errorloading"C:\Anaconda\Anaconda3\envs\TIN\lib\site-packages\torch\lib\caffe2_detectron_ops_gpu.dll"oroneofitsdependencies.在搜索很多关于无法查找到caffe2_detectron_ops_gpu
caffe/PyTorch/TensorFlow 在Jupyter Notebook GPU中运用俊俏的萌妹纸 caffe 人工智能深度学习
在JupyterNotebook中使用Caffe框架并利用GPU加速，可以实现多种效果和目的，主要集中在深度学习领域。以下是一些主要的应用场景：快速训练模型：GPU加速可以显著提高模型训练的速度。对于大型数据集和复杂的神经网络结构，使用GPU可以大大减少训练时间。实时数据增强：在训练过程中，可以实时地对输入数据进行变换和增强，以提高模型的泛化能力。GPU加速使得这些操作更加高效。大规模数据处理：深
Linux下Caffe、Docker、Tensorflow、PyTorch环境搭建(CentOS 7) SnailTyan
文章作者：Tyan博客：noahsnail.com|CSDN|注：模型的训练、测试、部署都可以通过Docker环境完成，环境问题会更少。1.CUDA8.0安装CUDA8.0Configenvvariables#CUDAPATHexportPATH="/usr/local/cuda-8.0/bin:$PATH"#CUDALDLIBRARY_PATHexportLD_LIBRARY_PATH="/us
JVM级缓存本地缓存Caffeine 旺仔爱Java JVM专题 jvm JVM缓存本地缓存 Caffeine Guava Cache
JVM级缓存本地缓存Caffeine和GuavaCache前言一、创建缓存的代码逻辑二、Caffeine的优化方面淘汰算法W-TinyLFU三、Caffeine的业务使用总结前言最新的Java面试题，技术栈涉及Java基础、集合、多线程、Mysql、分布式、Spring全家桶、MyBatis、Dubbo、缓存、消息队列、Linux…等等，会持续更新。一、创建缓存的代码逻辑Caffeine：publ
面试redis篇-04缓存雪崩卡搜偶缓存面试 redis
原理缓存雪崩：是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。解决方案：给不同的Key的TTL添加随机值利用Redis集群提高服务的可用性（哨兵模式、集群模式）给缓存业务添加降级限流策略（ngxin或springcloudgateway）给业务添加多级缓存（Guava或Caffeine）问答面试官：什么是缓存雪崩?怎么解决?回答：缓存雪崩意思是设
深度学习主流开源框架：Caffe、TensorFlow、Pytorch、Theano、Keras、MXNet、Chainer seasonsyy 深度学习小知识深度学习开源框架 pytorch
2.6深度学习主流开源框架表2.1深度学习主流框架参数对比框架关键词总结框架关键词基本数据结构（都是高维数组）Caffe“在工业中应用较为广泛”，“编译安装麻烦一点”BlobTensorFlow“安装简单pip”TensorPytorch“定位：快速实验研究”，“简单”，“灵活”TensorTheano×“用于处理大规模神经网络的训练”，“不支持移动设备”，“不能应用于工业环境”，“编译复杂模型时
MMsegmentation-随机初始化 SatVision炼金士 mmalb-炼金术 python
系列文章目录文章目录系列文章目录前言一、初始化单个模块二、初始化多个模块总结前言mmlab下游分支调用权重随机初始化使用参考mmengine的说明文档mmengine支持模型初始化方法包括：BaseInit,Caffe2XavierInit,ConstantInit,KaimingInit,NormalInit,PretrainedInit,TruncNormalInit,UniformInit,
解决：源码安装caffe时遇到libcudnn.so: file not recognized问题 Gracie丹妮
参考教程(19条消息)ubuntu16.04下Detectron+caffe2(Pytorch)安装配置过程_张家坎的博客-CSDN博客_caffe2_detectron_ops_gpu.dllhttps://blog.csdn.net/u014236392/article/details/81117287安装caffe2执行sudomakeinstall之后遇到如下问题:/home/Xdn/cu
进场行礼问候退场东方芭蕾Lily
1.当听到响铃声，按编号排队依次进入考场。tips：面带微笑，优雅自信且有礼貌的边看着考试官边跑到准备问好的位置。步伐轻盈像一阵风样，到位置站好一位脚，保持挺拔向上体态。小仙女就是你们。2.行礼问候Examier:(考试官)GillianMccafferyGoodmorning/afternoongirlsGoodmorning/afrernoonmadamorMs.MccafferyQuesti
YOLOv5独家改进：上采样算子 | 超轻量高效动态上采样DySample，效果秒杀CAFFE，助力小目标检测 AI小怪兽 YOLOv5原创自研 YOLO caffe 目标检测深度学习人工智能
本文独家改进：一种超轻量高效动态上采样DySample，具有更少的参数、FLOPs，效果秒杀CAFFE和YOLOv5网络中的nn.Upsample在多个数据集下验证能够涨点，尤其在小目标检测领域涨点显著。收录YOLOv5原创自研https://blog.csdn.net/m0_63774211/category_12511931.html全网独家首发创新（原创），适合paper！！！2024年计算
caffez转ncnn，及环境配置宁静深远软件安装
一、安装ncnn1、安装protobuf(a)、gitclonehttps://github.com/google/protobuf(b)、自动生成configure配置文件，运行：./autogen.sh(c)、配置环境：./configure(d)、编译源代码:make(e)、安装：sudomakeinstall(f)、刷新动态库:sudoldconfig2、安装ncnn(a)、mkdirco
最新姿态估计研究进展 a微风掠过
最新姿态估计研究进展自上而下：就是先检测包含人的框，即humanproposal，然后对框子中的人进行姿态估计。一般RCNN（区域CNN就是这个思路）自下而上：先检测keypoint，然后根据热力图、点与点之间连接的概率，根据图论知识，基于PAF（部分亲和字段）将关键点连接起来，将关键点分组到人。1、CMU：openpose研究多人的姿态估计运行环境：caffe自下而上，关键点被分组到人的实例时间
智慧云智能教育考试平台展示 barry200890 springboot vue 考试 java vue.js 小程序
智慧云智能教育平台项目简介技术架构1.1后端技术栈:*基于SpringBoot+MybatisPlus+Shiro+mysql5.7+redis+websocket构建.*使用jdk1.8的新特性如:caffeine缓存,lambda表达式.1.2前端技术:*Vue*Vuex*Vxe-Table(文档地址：https://gitee.com/xuliangzhan_admin/vxe-table)
what is SSD|Single Shot MultiBox Detector Woooooooooooooo
文章摘选自多篇文章，仅用于学习，在此表示感谢，若有侵权请联系，感谢论文下载地址：https://arxiv.org/abs/1512.02325论文代码：https://github.com/weiliu89/caffe/tree/ssd省去了区域建议网络，直接使用不同尺度featuremap中的cell得到priodbox（和anchor类似），利用卷积可以直接得到box的回归和score而不需
caffe中的参考模型雨住多一横
RCNNmode_reference_rcnn_ilsvrc13l.pngcaffenet用于Flickrstyle数据集model_finetune_flickr_style.pngAlexNetmodel_alexnet.pnggooglenetmodel_googlenet.pngcaffenetmodel_reference_caffenet.png
RT-DETR算法优化改进：上采样算子 | 超轻量高效动态上采样DySample，效果秒杀CAFFE，助力小目标检测 AI小怪兽 RT-DETR魔术师算法 caffe 目标检测 YOLO 深度学习人工智能
本文独家改进：一种超轻量高效动态上采样DySample，具有更少的参数、FLOPs，效果秒杀CAFFE和YOLOv8网络中的nn.Upsample在多个数据集下验证能够涨点，尤其在小目标检测领域涨点显著。RT-DETR魔术师专栏介绍：https://blog.csdn.net/m0_63774211/category_12497375.html✨✨✨魔改创新RT-DETR引入前沿顶会创新（CVPR
「性能提升」扩展 Spring Cache 支持多级缓存冷冷zz
为什么多级缓存缓存的引入是现在大部分系统所必须考虑的redis作为常用中间件，虽然我们一般业务系统（毕竟业务量有限）不会遇到如下图在随着data-size的增大和数据结构的复杂的造成性能下降，但网络IO消耗会成为整个调用链路中不可忽视的部分。尤其在微服务架构中，一次调用往往会涉及多次调用例如pigoauth2.0的client认证Caffeine来自未来的本地内存缓存,性能比如常见的内存缓存实现性
Spring Cache duration～ spring-boot spring java 后端
目录标题SpringCache1介绍2常用注解3入门SpringCache1介绍SpringCache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。SpringCache提供了一层抽象，底层可以切换不同的缓存实现，例如：EHCacheCaffeineRedis(常用)起步依赖：org.springframework.bootspring-boot-starter-
Caffeine与Spring cache的各种注解操作 500了 spring java 后端
前言Caffeine是一个基于Java8的进程内缓存框架，它使用乐观锁技术来提高并发吞吐量，并被誉为最快的缓存之一。Caffeine是内存型缓存，即缓存与调用者属于同一个应用，具体地说是属于同一个JVM。它的设计目标是提供高性能、高命中率以及低内存占用的本地缓存解决方案，被描述为GuavaCache的加强版和“新一代缓存”。关于Caffeine的使用，其提供了多种灵活的配置选项：自动加载数据：可以
缓存组件Caffeine的使用月月大王 Java #工具类缓存
caffeine是一个高性能的缓存组件，在需要缓存数据，但数据量不算太大，不想引入redis的时候，caffeine就是一个不错的选择。可以把caffeine理解为一个简单的redis。1、导入依赖com.github.ben-manes.caffeinecaffeine2.9.3导入是要注意版本，最开始我用的版本是3.1.1，不过启动是的时候会报错，这是因为我用的是jdk1.8，需要降低一下版本
Makefile.config walkMAN_aholic
##Refertohttp://caffe.berkeleyvision.org/installation.html#Contributionssimplifyingandimprovingourbuildsystemarewelcome!#cuDNNaccelerationswitch(uncommenttobuildwithcuDNN).USE_CUDNN:=1#CPU-onlyswitch(
缓存Caffeine之W-TinyLFU淘汰策略 georgesnoopy guava 缓存 java 淘汰策略 Caffeine
我们常见的缓存是基于内存的缓存，但是单机的内存是有限的，不能让缓存数据撑爆内存，所有需要缓存淘汰机制。https://mp.csdn.net/editor/html/115872837中大概说明了LRU的缓存淘汰机制，以及基于LRU的著名实现guavacache。除了LRU淘汰策略外，其是常见的还有FIFO以及LFU，只是说目前用的最多的是LRU。LRULRU记录了缓存中数据项的访问时间，在缓存数
Caffeine史上最快的内存缓存奇遇少年缓存 java
引言在现代的Web应用程序中，缓存是提升性能，减少数据库负载，加快响应速度的关键技术之一。SpringBoot作为一个简化Spring应用开发的框架，提供了与多种缓存技术集成的支持。Caffeine是一个高性能，灵活的缓存库，它可以作为本地缓存在Java应用中广泛使用。本文将详细介绍如何在SpringBoot项目中集成Caffeine缓存，并通过一个实例来展示它的使用。什么是Caffeine缓存？
如何解决caffe和video-caffe不能使用cudnn8编译的问题 Arnold-FY-Chen video-caffe 深度学习 Caffe video-caffe caffe 深度学习 cudnn8 cudnn
因为caffe之类的代码很久不更新了，只支持到了使用cudnn7.x，在使用了cudnn8的环境下编译caffe或video-caffe时，会在src/caffe/layers/cudnn_conv_layer.cpp等文件里出错：error:identifier"CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT"isundefinederror:iden
Redis 6.0 客户端缓存极简博客 java redis
不难发现，我们经常将Redis作为系统的缓存服务，但你有没有发现。在我们每次操作Redis时，都需要发送网络请求。这样就避免不了网络的开销。但如何解决这个问题呢？我们引入了本地缓存来解决此问题。查询逻辑从先前的直接查询转变为：先通过查询本地缓存，不存在再去远程查找然后设置到本地缓存-适用于分布式客户端缓存。有没有感觉像我们使用过的本地缓存Guava、Caffeine等一样？有啥特别的？这里Redi
[图像算法]-(yolov5.train)-GPU架构中的半精度fp16与单精度fp32计算蒸饺与白茶
GPU架构中的半精度与单精度计算由于项目原因，我们需要对darknet中卷积层进行优化，然而对于像caffe或者darknet这类深度学习框架来说，都已经将卷积运算转换成了矩阵乘法，从而可以方便调用cublas库函数和cudnn里tiling过的矩阵乘。 CUDA在推出7.5的时候提出了可以计算16位浮点数据的新特性。定义了两种新的数据类型half和half2.之前有师弟已经DEMO过半精度
caffe搭建深度神经网络 A异乡人_7a44
利用Caffe进行深度神经网络训练第一步需要搞懂几个重要文件：solver.prototxttrain_val.prototxttrain.shsolver.prototxtsolver这个文件主要存放模型训练所用到的一些超参数：net:=指定待训练模型结构文件，即train_val.prototxttest_interval:=测试间隔，即每隔多少次迭代进行一次测试test_initializa
deep-visualization-toolbox可视化安装 2014wzy caffe框架
运行环境：Linux+caffe步骤：Step0:Compilemasterbranchofcaffe本代码运行的前提是，配置过caffe。因为配置caffe的过程中会出现一些依赖库，正是本代码所需要的。http://blog.csdn.NET/u011204487/article/details/51596471是配置caffe的过程。注意Makefile.config中的CPU_ONLY:=1
xml解析小猪猪08 xml
1、DOM解析的步奏准备工作： 1.创建DocumentBuilderFactory的对象 2.创建DocumentBuilder对象 3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件 4.通过Document的getElem
每个开发人员都需要了解的一个SQL技巧 brotherlamp linux linux视频 linux教程 linux自学 linux资料
对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： CREATE TABLE books ( id &
Quartz——CronTrigger触发器 eksliang quartz CronTrigger
转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。二.Cron表达式介绍 1）Cron表达式规则表 Quartz
Informatica基础 18289753290 Informatica Monitor manager workflow Designer
1. 1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 2）Workflow Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 3）Workflow Monitor：监控Workflow和Session运行情况，生成日志和报告 4）Repository Manager：
linux下为程序创建启动和关闭的的sh文件，scrapyd为例酷的飞上天空 scrapy
对于一些未提供service管理的程序每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件下面以scrapy启动server为例，文件名为run.sh： #端口号，根据此端口号确定PID PORT=6800 #启动命令所在目录 HOME='/home/jmscra/scrapy/' #查询出监听了PORT端口
人--自私与无私永夜-极光
今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么? 从客观的角度来看,人有自私的行为,也有无私的
Ubuntu安装NS-3 环境脚本随便小屋 ubuntu
将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令： sudo ./ns3environment.sh >>result 这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示 com
创业的简单感受 aijuans 创业的简单感受
2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
如何经营自己的独立人脉 aoyouzi 如何经营自己的独立人脉
独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。以一个普通的银行柜员
JSP基础百合不是茶 jsp 注释隐式对象
1,JSP语句的声明 <%! 声明 %> 　　声明：这个就是提供java代码声明变量、方法等的场所。表达式 <%= 表达式 %> 　　这个相当于赋值，可以在页面上显示表达式的结果，程序代码段/小型指令　<% 程序代码片段 %> 2,JSP的注释
web.xml之session-config、mime-mapping bijian1013 java web.xml servlet session-config mime-mapping
session-config 1.定义： <session-config> <session-timeout>20</session-timeout> </session-config> 2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。 mime-mapping 1.定义： <mime-m
互联网开放平台（1） Bill_chen 互联网 qq 新浪微博百度腾讯
现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 1.淘宝开放平台(TOP) 网址：http://open.taobao.com/ 依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。目前TOP的三条主线： TOP访问网站：open.taobao.com ISV后台：my.open.ta
【MongoDB学习笔记九】MongoDB索引 bit1129 mongodb
索引可以在任意列上建立索引索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 使用索引可以加快查询,但同时会降低修改,插入等的性能内嵌文档照样可以建立使用索引测试数据 var p1 = { "name":"Jack", "age&q
JDBC常用API之外的总结白糖_ jdbc
做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。 ResultSetMetaData获取ResultSet对象的元数据信息
apache VelocityEngine使用记录 bozch VelocityEngine
VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。使用方法如下： VelocityEngine engine = new VelocityEngine();// 定义模板引擎 Properties properties = new Properties();// 模板引擎属
编程之美-快速找出故障机器 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; public class TheLostID { /*编程之美假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。 1.假设在某个时间得到一个数据文件ID的列表，是
关于Java中redirect与forward的区别 chenbowen00 java servlet
在Servlet中两种实现： forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); redirect方式：response.sendRedirect(“/somePage.jsp”); forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
[信号与系统]人体最关键的两个信号节点 comsci 系统
如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做百汇穴, 另外一个节点在腰部,中医的名称叫做命门如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
oracle 存储过程执行权限 daizj oracle 存储过程权限执行者调用者
在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 CREATE OR REPLACE PROCEDURE TestProc IS fla
为mysql数据库建立索引 dengkane mysql 性能索引
前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
学习C语言常见误区如何看懂一个程序如何掌握一个程序以及几个小题目示例 dcj3sjt126com c 算法
如果看懂一个程序，分三步 1、流程 2、每个语句的功能 3、试数如何学习一些小算法的程序尝试自己去编程解决它，大部分人都自己无法解决如果解决不了就看答案关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义照着答案去敲调试错误
centos6.3安装php5.4报错 dcj3sjt126com centos6
报错内容如下: Resolving Dependencies --> Running transaction check ---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed --> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for
JSONP请求 flyer0126 jsonp
使用jsonp不能发起POST请求。 It is not possible to make a JSONP POST request. JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
Spring Security（03）——核心类简介 234390216 Authentication
核心类简介目录 1.1 Authentication 1.2 SecurityContextHolder 1.3 AuthenticationManager和AuthenticationProvider 1.3.1 &nb
在CentOS上部署JAVA服务 java--hhf java jdk centos Java服务
本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行第一步：卸载旧Linux自带的JDK ①查看本机JDK版本 java -version 结果如下 java version "1.6.0"
oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date] ldzyz007 oracle mysql SQL Server
oracle &n
记Protocol Oriented Programming in Swift of WWDC 2015 ningandjin protocol WWDC 2015 Swift2.0
其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭，把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS rensanning keepalived
（一）Keepalived （1）安装 # cd /usr/local/src # wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz # tar zxvf keepalived-1.2.15.tar.gz # cd keepalived-1.2.15 # ./configure # make &a
ORACLE数据库SCN和时间的互相转换 tomcat_oracle oracle sql
SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换；　　用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了；　　操作方法：　　1、通过dbms_f
Spring MVC 方法注解拦截器 xp9802 spring mvc
应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理先看一个实例,使用@access_required拦截： ?

【撸码caffe 三】 caffe.cpp

你可能感兴趣的:(caffe)