ciky奇

Caffe学习之——caffe.cpp源码解析

本文主要解析caffe源码中/tools/caffe.cpp文件，此文件是caffe程序的入口main函数，包含了命令行参数代码实现，如tain,test，time等。

caffe结构请参考： https://blog.csdn.net/c20081052/article/details/80585888

caffe命令行参数请参考： https://blog.csdn.net/c20081052/article/details/80596572

代码注释如下：

#ifdef WITH_PYTHON_LAYER
#include "boost/python.hpp"   //下面两个是Boost.Python实现Python C/C++混合编程（具体参考boost.python）
namespace bp = boost::python;
#endif

#include  //下面俩是google开源的命令行参数解析工具
#include 

#include 
#include 
#include 
#include 

#include "boost/algorithm/string.hpp"
#include "caffe/caffe.hpp"
#include "caffe/util/signal_handler.h" //这个我暂且解析为信息处理头文件，会对作者输入的命令行参数做处理，比如stop，snapshot,none

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;


/*gflags是google的一个开源的处理命令行参数的库。
  在使用命令行参数的文件文件中（源文件或头文件），首先使用一下定义语句进行变量的定义。
  DEFINE_int32，DEFINE_int64，DEFINE_bool，DEFINE_double，DEFINE_string等，
  语法为：DEFINE_int32(name, default_value, "description")。
  接着你就可以使用FLAGS_name变量了，这些变量的值则是由命令行参数传递，无则为默认值，
  在其他代码文件中若想用该命令参数，可以用DECLARE_int32(name)声明（name为int32类型，也可以使用其他支持的类型）。
  在caffe.cpp中有很多FLAGS_name定义，如DEFINE_string(gpu,"","some description"），则命令行后-gpu 0，表示FLAGS_gpu=0，默认值为空。*/
DEFINE_string(gpu, "",
    "Optional; run in GPU mode on given device IDs separated by ','."      //如果有多个GPU做处理，用，分隔
    "Use '-gpu all' to run on all available GPUs. The effective training "   //使用所有GPU
    "batch size is multiplied by the number of devices.");   //那么一次处理图片数是batchsize*GPU数
DEFINE_string(solver, "",
    "The solver definition protocol buffer text file.");  //一种‘.prototxt格式文件’
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, "  //加载预训练模型权重参数，便于网络finetune，不可与snapshot参数共用
    "separated by ','. Cannot be set simultaneously with snapshot.");
DEFINE_int32(iterations, 50,                    //默认迭代次数是50，一次batchsize个
    "The number of iterations to run.");
DEFINE_string(sigint_effect, "stop",        //当有中断信号输入时使用的参数，用户可传入中断后训练的动作，比如stop，或记录snapshot或不做none.
             "Optional; action to take when a SIGINT signal is received: "
              "snapshot, stop or none.");
DEFINE_string(sighup_effect, "snapshot",  //当训练被挂起时定义相应的动作，比如记录snapshot，stop,或none
             "Optional; action to take when a SIGHUP signal is received: "
             "snapshot, stop or none.");

// A simple registry for caffe commands.
typedef int (*BrewFunction)();  /*声明了一个BrewFunction函数指针类型，可以用它来定义一个函数指针*/
typedef std::map BrewMap;  /*因为输入参数可能为train，test，device_query，time，所以定义一个容器类型*/
BrewMap g_brew_map;  /*定义在上午key为string的map容器实例*/

/*这里巧妙的用宏定义的方式声明了分别包含train()，test()，
   device_query()，time()四个函数的四个不同类*/
   /*理解这个关键理解宏在预编译阶段是如何被展开*/
#define RegisterBrewFunction(func) \
namespace { \
class __Registerer_##func { \
 public: /* NOLINT */ \
  __Registerer_##func() { \
    g_brew_map[#func] = &func; \
  } \
}; \
__Registerer_##func g_registerer_##func; \
}
//在C/C++的宏中，"#"的功能是将其后面的宏参数进行字符串化操作(Stringfication)，简单说就是在对它所引用的宏变量通过替换后在其左右各加上一个双引号。  
//”##”被称为连接符(concatenator)，用来将两个子串Token连接为一个Token。注意这里连接的对象是Token就行，而不一定是宏的变量。 




/*在caffe.cpp 中 BrewFunction 作为GetBrewFunction()函数的返回类型，
  可以是 train()，test()，device_query()，time() 这四个函数指针的其中一个。
  在train()，test()，中可以调用solver类的函数，从而进入到net，进入到每一层，运行整个caffe程序。*/
static BrewFunction GetBrewFunction(const caffe::string& name) {
  if (g_brew_map.count(name)) { //判断输入的是不是g_brew_map中train，test，device_query，time中一个
    return g_brew_map[name];     //如果是的话，就调用相应的train(),test()，device_query()，time()
  } 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来源于google的glog库，控制程序的日志输出消息和测试消息 
    }
    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  //如果未定义了只用CPU的话，CUDA会寻找可用GPU
    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]));    //将所有GPU的id存进gpus
    }
  } else {
    CHECK_EQ(gpus->size(), 0);   //检查gpu是否没有
  }
}

// Parse phase from flags  //解析是训练还是测试阶段
caffe::Phase get_phase_from_flags(caffe::Phase default_value) {
  if (FLAGS_phase == "")  //用户未输入的话是默认train
    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.
int device_query() {     /*这里定义device_query函数*/   //显示gpu设备的诊断信息
  LOG(INFO) << "Querying GPUs " << FLAGS_gpu;
  vector gpus;
  get_gpus(&gpus);/*获得有几个GPU*/
  for (int i = 0; i < gpus.size(); ++i) { /*依次查询每个GPU信息*/
    caffe::Caffe::SetDevice(gpus[i]);
    caffe::Caffe::DeviceQuery();
  }
  return 0;
}
RegisterBrewFunction(device_query); /*这里通过预编译阶段的宏替换，将定义的device_query函数指针赋值到map容器中*/

/*加载训练的或者传入的模型*/
// Load the weights from the specified caffemodel(s) into the train and
// test nets.
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]);
    }
  }
}

//将交互端传来的string类型的标志转成枚举类型的变量
// Translate the signal effect the user specified on the command-line to the
// corresponding enumeration.
caffe::SolverAction::Enum GetRequestedAction(    //枚举所有传入的交互端指令，可为'stop','snapshot','none'
    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";
}

// Train / Finetune a model.
/*训练或者微调网络都是走这个分支*/
int train() {   /*定义train函数*/
  // google的glog库，检查--solver、--snapshot和--weight并输出消息；必须有指定solver，并且snapshot和weight两者只需指定其一；  
  CHECK_GT(FLAGS_solver.size(), 0) << "Need a solver definition to train.";   //必须传入solver文件
  CHECK(!FLAGS_snapshot.size() || !FLAGS_weights.size())
      << "Give a snapshot to resume training or weights to finetune "
      "but not both.";                //snapshot和weight两者不能同时存在
  vector stages = get_stages_from_flags();

  /*SolverParameter是通过Google Protocol Buffer自动生成的一个类*/
  caffe::SolverParameter solver_param;  /*定义SolverParameter的对象，该类保存solver参数和相应的方法*/
  caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param);//将-solver指定solver.prototxt文件内容解析到solver_param中  

  solver_param.mutable_train_state()->set_level(FLAGS_level);  //此处定义了level和stage ，应该在caffe::Net函数中有具体定义
  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.
  if (FLAGS_gpu.size() == 0 //根据命令参数-gpu或者solver.prototxt提供的信息设置GPU
      && solver_param.solver_mode() == caffe::SolverParameter_SolverMode_GPU) {
      if (solver_param.has_device_id()) {  //如果solver.prototxt提供GPU信息就用其gpuid
          FLAGS_gpu = "" +
              boost::lexical_cast(solver_param.device_id());
      } else {  // Set default GPU if unspecified
          FLAGS_gpu = "" + boost::lexical_cast(0);//boost::lexical_cast(0)是将数值0转换为字符串'“0”；
      }
  }
  /*上述代码:::: 首先是判断用户在Command Line中是否输入了gpu相关的参数，
                 如果没有(FLAGS_gpu.size()==0)但是用户在solver的prototxt定义中提供了相关的参数，
                 那就把相关的参数放到FLAGS_gpu中，如果用户仅仅是选择了在solver的prototxt定义中选择了GPU模式，
                 但是没有指明具体的gpu_id，那么就默认设置为0。*/


  //多GPU下，将GPU编号存入vector容器中（get_gpus()函数通过FLAGS_gpu获取）
  vector gpus;
  get_gpus(&gpus);
  if (gpus.size() == 0) {
    LOG(INFO) << "Use CPU.";
    Caffe::set_mode(Caffe::CPU);
  } else {
    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(&device_prop, gpus[i]);
      LOG(INFO) << "GPU " << gpus[i] << ": " << device_prop.name;
    }
    #endif
    solver_param.set_device_id(gpus[0]);
    Caffe::SetDevice(gpus[0]);
    Caffe::set_mode(Caffe::GPU);
    Caffe::set_solver_count(gpus.size());
  }

  //处理snapshot, stop or none信号，其声明在include/caffe/util/signal_Handler.h中；
  //GetRequestedAction在caffe.cpp中，将‘stop’，‘snapshot’，‘none’转换为标准信号，即解析；
  caffe::SignalHandler signal_handler(
        GetRequestedAction(FLAGS_sigint_effect),
        GetRequestedAction(FLAGS_sighup_effect));

   //声明boost库中智能指针solver，指向caffe::Solver对象，该对象由CreateSolver创建；
  shared_ptr >
      solver(caffe::SolverRegistry::CreateSolver(solver_param));   /*这里初始化网络*/

  /*通过GetActionFunction来处理获得的系统信号*/
  /*在SetActionFunction中将GetActionFunction函数地址传给参数action_request_function_*/
  /*在网络训练的过程中，在GetRequestedAction中来处理action_request_function_得到的函数指针*/
  solver->SetActionFunction(signal_handler.GetActionFunction());

  //判断了一下用户是否定义了snapshot或者weights这两个参数中的一个
  //如果定义了则需要通过Solver提供的接口从snapshot或者weights文件
  //中去读取已经训练好的网络的参数，来接着训练
  if (FLAGS_snapshot.size()) {
    LOG(INFO) << "Resuming from " << FLAGS_snapshot;
    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();  //开始优化网络
  }
  LOG(INFO) << "Optimization Done.";
  return 0;
}
RegisterBrewFunction(train);  /*将train函数指针，指到map容器中*/


// Test: score a model.
int test() {  /*定义测试函数*/
  CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to score."; /*判断是否传入网络*/
  CHECK_GT(FLAGS_weights.size(), 0) << "Need model weights to score.";    /*判断是否传入模型*/
  vector stages = get_stages_from_flags();

  // Set device id and mode   设置设备id（如gpu）以及训练是否用gpu
  vector gpus;
  get_gpus(&gpus);  /*获得GPU信息*/
  if (gpus.size() != 0) {
    LOG(INFO) << "Use GPU with device ID " << gpus[0];
    #ifndef CPU_ONLY  /*如果没只用CPU那么就要获得GPU信息*/
    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 { /*如果没有GPU就在CPU上处理*/
    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：：：传入的迭代次数，一次迭代一个batch*/
    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) {    /*打印每次迭代的accuracy与loss信息*/
      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]];
        LOG(INFO) << "Batch " << i << ", " << output_name << " = " << score;
      }
    }
  }
  loss /= FLAGS_iterations;  //所有迭代次数的总损失/迭代次数=平均每次迭代的损失
  LOG(INFO) << "Loss: " << loss;   /*打印测试的结果总的平均的accuracy与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函数指针，指到map容器中*/


// 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); //传入train命令参数
  vector stages = get_stages_from_flags();

  // Set device id and mode
  vector gpus;
  get_gpus(&gpus);   /*读取GPU信息*/
  if (gpus.size() != 0) {  /*如果有就用GPU*/
    LOG(INFO) << "Use GPU with device ID " << gpus[0];
    Caffe::SetDevice(gpus[0]);
    Caffe::set_mode(Caffe::GPU);
  } else {
    LOG(INFO) << "Use CPU.";  /*如果没有就只用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);/*将time函数指针，指到map容器中*/

int main(int argc, char** argv) {         //主函数入口
  // Print output to stderr (while still logging).
  FLAGS_alsologtostderr = 1;
  // Set version
  gflags::SetVersionString(AS_STRING(CAFFE_VERSION));
  // 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");
  // Run tool or show usage.
  caffe::GlobalInit(&argc, &argv);  /*解析传入的Google Flags*/
  if (argc == 2) {
#ifdef WITH_PYTHON_LAYER
    try {
#endif  /*传入train，test，device_query，time命令时,进入这个分支调用这个函数*/
      return GetBrewFunction(caffe::string(argv[1]))();  /*argv[1]就是传入的参数train/test/device_query,time*/
#ifdef WITH_PYTHON_LAYER
    } catch (bp::error_already_set) {
      PyErr_Print();
      return 1;
    }
#endif
  } else {
    gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/caffe");    //要求参数argv[0]包含tools/caffe
  }
}

参考：https://blog.csdn.net/lanxuecc/article/details/52934133

深度学习框架人工智能操作系统训练&前向推理 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
强大的销售团队背后竟然是大数据分析的身影蓝儿唯美数据分析
Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡 keepalived haproxy 高可用
我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过服务器资源 10.7
eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
基础篇--resources资源不懂事的小屁孩 android
最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml 字符串资源涉及国际化问题 http://www.2cto.com/kf/201302/190394.html string-array
接上篇补上window平台自动上传证书文件的批处理问卷酷的飞上天空 window
@echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
企业物联网大潮涌动：如何做好准备？蓝儿唯美企业
物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
spring学习——数据库（mybatis持久化框架配置） a-john mybatis
Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
Java静态代理、动态代理实例 aijuans Java静态代理
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。按照代理类的创建时期，可以分为：静态代理和动态代理。所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。一、静态代理类实例： 1、Serivce.ja
Struts1与Struts2的12点区别 asia007 Struts1与Struts2
1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
初学者要多看看帮助文档不要用js来写Jquery的代码百合不是茶 jquery js
解析json数据的时候需要将解析的数据写到文本框中, 出现了用js来写Jquery代码的问题; 1, JQuery的赋值有问题代码如下: data.username 表示的是: 网易 $("#use
经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenu tree Richfaces
组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。 Ubuntu上安装Red
JSONObject转换JSON--将Date转换为指定格式白糖_ JSONObject
项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式： {"nanos":0,"time":-27076233600000,
JavaScript语言精粹读书笔记 braveCS JavaScript
【经典用法】： //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
编程之美-找符合条件的整数用字符串来表示大整数避免溢出 bylijinnan 编程之美
import java.util.LinkedList; public class FindInteger { /** * 编程之美找符合条件的整数用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
读书笔记 chengxuyuancsdn 读书笔记
1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
[通讯与电力]光网城市建设的一些问题 comsci 问题
信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........
oracle 空间RESUMABLE daizj oracle 空间不足 RESUMABLE 错误挂起
空间RESUMABLE操作转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。这一篇简单介绍空间RESUMABLE的例子。第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
重构第一次写的线程池 dieslrae 线程池 python
最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
C语言学习六指针 dcj3sjt126com c
初识指针，简单示例程序： /* 指针就是地址，地址就是指针地址就是内存单元的编号指针变量是存放地址的变量指针和指针变量是两个不同的概念但是要注意：通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }
timertask shuizhaosi888 timertask
java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
Spring Security（13）——session管理 234390216 session Spring Security 攻击保护超时
session管理目录 1.1 检测session超时 1.2 concurrency-control 1.3 session 固定攻击保护
公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodb session nodejs
http://www.upopen.cn 一、前言书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
pojo.vo.po.domain区别 LiaoJuncai java VO POJO javabean domain
　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。　　　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
Windows Error Code OhMyCC windows
0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
在storm集群环境下发布Topology roadrunners 集群 storm topology spout bolt
storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。 1、打包打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
为什么不允许代码里出现“魔数” tomcat_oracle java
　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。　　很多开发者在这个检查方面都有问题，这可以从结果
zoj 3511 Cake Robbery(线段树) 阿尔萨斯线段树
题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&

Caffe学习之——caffe.cpp源码解析

你可能感兴趣的:(caffe,caffe.cpp)