【Caffe】002 caffe.cpp源码解析

TensorFlow 1.14 部署 Mask R-CNN 工业实践指南 Mask R-CNN 是两阶段实例分割的代表性模型,其核心原理是在 Faster R-CNN 基础上引入掩码分支,实现像素级目标定位与分类联合输出。该技术具备强空间建模能力,在工业质检、医疗影像和自动驾驶等需精确轮廓分析的场景中具有不可替代的技术价值。相比 YOLO 等单阶段检测器,Mask R-CNN 天然支持实例级 mask 生成,无需额外设计分割头或重写损失函数。在老旧产线环境(如 CUDA 10.0、CentOS 7、Tesla P40)下,TensorFlow 1.14 成为兼顾稳定性、Keras 阅读详情

path-to-caffe/include/caffe/caffe.hpp

// caffe.hpp is the header file that you need to include in your code. It wraps
// all the internal caffe header files into one for simpler inclusion.

#ifndef CAFFE_CAFFE_HPP_
#define CAFFE_CAFFE_HPP_

#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/filler.hpp"
#include "caffe/layer.hpp"
#include "caffe/layer_factory.hpp"
#include "caffe/net.hpp"
#include "caffe/parallel.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/solver.hpp"
#include "caffe/solver_factory.hpp"
#include "caffe/util/benchmark.hpp"
#include "caffe/util/io.hpp"
#include "caffe/util/upgrade_proto.hpp"

#endif  // CAFFE_CAFFE_HPP_
path-to-caffe/tools/caffe.cpp

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

#include <gflags/gflags.h>
#include <glog/logging.h>

#include <cstring>
#include <map>
#include <string>
#include <vector>

#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;

// GFLAGS,用于命令行解析
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.");

// Caffe命令注册
typedef int (*BrewFunction)();
typedef std::map<caffe::string, BrewFunction> BrewMap;
BrewMap g_brew_map;

#define RegisterBrewFunction(func) \
namespace { \
class __Registerer_##func { \
 public: /* NOLINT */ \
  __Registerer_##func() { \
    g_brew_map[#func] = &func; \
  } \
}; \
__Registerer_##func g_registerer_##func; \
}

static BrewFunction GetBrewFunction(const caffe::string& name) {
  if (g_brew_map.count(name)) {
    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.
  }
}

// 解析命令行参数 -gpu
// 使用指定ID的GPU,或者使用所有可用的GPU。
static void get_gpus(vector<int>* gpus) {
  if (FLAGS_gpu == "all") { // 对应命令行参数 -gpu all
    int count = 0;
#ifndef CPU_ONLY
    CUDA_CHECK(cudaGetDeviceCount(&count)); // 获取可用GPU数量
#else
    NO_GPU;
#endif
    for (int i = 0; i < count; ++i) {
      gpus->push_back(i);
    }
  } else if (FLAGS_gpu.size()) {
    vector<string> strings;
    boost::split(strings, FLAGS_gpu, boost::is_any_of(",")); // 对应命令行指定多个GPU设备ID号时用“,”间隔
    for (int i = 0; i < strings.size(); ++i) {
      gpus->push_back(boost::lexical_cast<int>(strings[i]));
    }
  } else {
    CHECK_EQ(gpus->size(), 0);
  }
}

// 解析命令行参数 -phase
// 指定TRAIN或TEST阶段,评估模型计算耗时(time命令)时使用。
// 该函数只被time()函数调用,default_value=caffe::TRAIN。
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
}

// 解析命令行参数 -stage
vector<string> get_stages_from_flags() {
  vector<string> stages;
  boost::split(stages, FLAGS_stage, boost::is_any_of(","));
  return stages;
}

// caffe命令调用形式如下
//     caffe <command> <args>
//
// 如果想要增加新的命令,先定义相应函数"int command()",
// 然后使用RegisterBrewFunction(command)进行注册。

// 设备诊断:显示指定GPU设备(-gpu参数)的诊断信息
int device_query() {
  LOG(INFO) << "Querying GPUs " << FLAGS_gpu;
  vector<int> gpus;
  get_gpus(&gpus);
  for (int i = 0; i < gpus.size(); ++i) {
    caffe::Caffe::SetDevice(gpus[i]); // 调用cudaGetDevice()
    caffe::Caffe::DeviceQuery(); // 调用cudaGetDeviceProperties()
  }
  return 0;
}
RegisterBrewFunction(device_query);

// 解析命令行参数 -weights,即model_list
// 从指定caffemodel(s)文件中载入预训练的(训练/测试)网络模型参数
void CopyLayers(caffe::Solver<float>* solver, const std::string& model_list) {
  std::vector<std::string> 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]);
    }
  }
}

// 解析命令行参数 -sighup_effect 和 -sigint_effect
// 设置训练时(train命令)接收到挂起或中断信号时的处理机制
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";
}

// 训练或微调
int train() {
  CHECK_GT(FLAGS_solver.size(), 0) << "Need a solver definition to train."; // 必须有-solver参数
  CHECK(!FLAGS_snapshot.size() || !FLAGS_weights.size()) // 不能同时设置-snapshot和-weight参数
      << "Give a snapshot to resume training or weights to finetune "
      "but not both.";
  vector<string> stages = get_stages_from_flags();

  caffe::SolverParameter solver_param;
  caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param); // 从solver定义文件中解析solver参数

  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]);
  }

  // 如果命令行没有使用-gpu参数指定GPU设备,查看solver定义文件中是否指定使用GPU。
  // solver定义文件中使用solver_mode指定使用GPU/CPU,使用device_id指定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<string>(solver_param.device_id());
      } else {  // 如果solver定义文件中指定使用GPU但未指定ID号,默认使用ID=0的GPU设备。
          FLAGS_gpu = "" + boost::lexical_cast<string>(0);
      }
  }

  // 设置使用的GPU设备及运行模式
  vector<int> 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());
  }

  // 设置训练时(train命令)接收到挂起或中断信号时的处理机制
  caffe::SignalHandler signal_handler(
        GetRequestedAction(FLAGS_sigint_effect),
        GetRequestedAction(FLAGS_sighup_effect));

  shared_ptr<caffe::Solver<float> >
      solver(caffe::SolverRegistry<float>::CreateSolver(solver_param));

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

  // 解析命令行参数 -snapshot
  // 从之前保存的快照中恢复训练状态
  if (FLAGS_snapshot.size()) {
    LOG(INFO) << "Resuming from " << FLAGS_snapshot;
    solver->Restore(FLAGS_snapshot.c_str());
  }
  // 解析命令行参数 -weights
  // 从指定caffemodel(s)文件中载入预训练的(训练/测试)网络模型参数
  else if (FLAGS_weights.size()) {
    CopyLayers(solver.get(), FLAGS_weights);
  }

  // 多GPU并行
  if (gpus.size() > 1) {
    caffe::P2PSync<float> sync(solver, NULL, solver->param());
    sync.Run(gpus);
  } else {
    LOG(INFO) << "Starting Optimization";
    solver->Solve();
  }
  LOG(INFO) << "Optimization Done.";
  return 0;
}
RegisterBrewFunction(train);

// 评估已训练模型性能
int test() {
  CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to score."; // 必须有-model参数
  CHECK_GT(FLAGS_weights.size(), 0) << "Need model weights to score."; // 必须有-weight参数
  vector<string> stages = get_stages_from_flags();

  // 设置使用的GPU设备及运行模式
  vector<int> gpus;
  get_gpus(&gpus);
  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);
  }
  
  // 实例化网络模型
  Net<float> caffe_net(FLAGS_model, caffe::TEST, FLAGS_level, &stages);
  // 解析命令行参数 -weights
  // 从指定caffemodel(s)文件中载入已训练的测试网络模型参数
  caffe_net.CopyTrainedLayersFrom(FLAGS_weights);
  LOG(INFO) << "Running for " << FLAGS_iterations << " iterations."; // -iterations参数指定迭代次数

  vector<int> test_score_output_id;
  vector<float> test_score;
  float loss = 0;
  for (int i = 0; i < FLAGS_iterations; ++i) {
    float iter_loss;
    const vector<Blob<float>*>& 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]];
        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);

// 评估模型执行耗时
int time() {
  CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to time."; // 必须有-model参数
  caffe::Phase phase = get_phase_from_flags(caffe::TRAIN); // 默认-phase参数为TRAIN
  vector<string> stages = get_stages_from_flags();

  // 设置使用的GPU设备及运行模式
  vector<int> 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);
  }
  
  // 实例化网络模型
  Net<float> caffe_net(FLAGS_model, phase, FLAGS_level, &stages);

  // 预先做一次完整的前向-反向传播,完成相应内存分配,后续迭代会更加稳定。
  // 在进行耗时评估时,假定网络没有输入blobs。
  LOG(INFO) << "Performing Forward";
  float initial_loss;
  caffe_net.Forward(&initial_loss);
  LOG(INFO) << "Initial loss: " << initial_loss;
  LOG(INFO) << "Performing Backward";
  caffe_net.Backward();

  const vector<shared_ptr<Layer<float> > >& layers = caffe_net.layers();
  const vector<vector<Blob<float>*> >& bottom_vecs = caffe_net.bottom_vecs();
  const vector<vector<Blob<float>*> >& top_vecs = caffe_net.top_vecs();
  const vector<vector<bool> >& bottom_need_backward =
      caffe_net.bottom_need_backward();
  LOG(INFO) << "*** Benchmark begins ***";
  LOG(INFO) << "Testing for " << FLAGS_iterations << " iterations."; // -iterations参数指定迭代次数
  Timer total_timer;
  total_timer.Start();
  Timer forward_timer;
  Timer backward_timer;
  Timer timer;
  std::vector<double> forward_time_per_layer(layers.size(), 0.0);
  std::vector<double> 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) {
  // 将日志输出到文件,同时输出到终端屏幕.
  FLAGS_alsologtostderr = 1;
  // Caffe版本
  gflags::SetVersionString(AS_STRING(CAFFE_VERSION));
  // 用法信息
  gflags::SetUsageMessage("command line brew\n"
      "usage: caffe <command> <args>\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");
  // 使用GFLAGS解析命令行参数,并初始化GLOG用于日志输出。
  caffe::GlobalInit(&argc, &argv);
  
  if (argc == 2) {
#ifdef WITH_PYTHON_LAYER
    try {
#endif
      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");
  }
}


深度学习框架Caffe源码解析 作者:薛云峰(https://github.com/HolidayXue),主要从事视频图像算法的研究,就职于浙江捷尚视觉科技股份有限公司担任深度学习算法研究员。 本文来源微信公众号:深度学习大讲堂。 原文:深度学习框架Caffe源码解析 欢迎技术投稿、约稿、给文章纠错,请发送邮件至heyc@csdn.net 相信社区中很多小伙伴和我一样使用了很长时间的Caffe深度学习框... 阅读详情

相关推荐

多接口COM组件的调用(COM002)

多接口COM组件的调用(COM002) 多接口COM组件的调用(COM002) 多接口COM组件的调用(COM002)

caffe源码解读

caffe源码解读Caffe组成结构Blob模块SyncedMemory类layer类输入层Data Layer网络层ReLULayer Caffe组成结构 caffe主要由下列4个类组成:Blob;layer;Net;Solver。主要功能如下: caffe.proto定义了多个message结构体,它包含了网络需要传递的参数。required是必须要定义的,optional是可选的(后面可加默...

renchenliang的博客 713

caffe源代码解析

对caffe的源代码有较为详细的分析,适合想要自己在caffe上更改代码的人。

caffe 源码解读

caffe 源码解读 作为算法工程师,在调库的时候,总会好奇,what is under the hood?在这种好奇心的驱使下,我读了caffe的源码。caffe代码量5万行左右,比较简洁。 caffe 是个轻量级的深度学习库,在计算机视觉领域用的比较多。提升代码能力有两种途径,一是多写,二是多读。相比自己写bug ridden 的代码,读优秀的代码是一件非常愉快的事情。caffe代码量5万行左...

zhenhailiu的博客 4682

Caffe源码深入解析

Caffe源码深入解析 Caffe源码深入解析 - caffe的源码实现深入解读,包括框架介绍和各类信息的总结,部分内容总结之网络,仅供大家学习和参考使用

电流采样(分流器与霍尔传感器)

霍尔效应霍尔效应是磁电效应的一种,这一现象是霍尔(A.H.Hall,1855—1938)于1879年在研究金属的导电机构时发现的。霍尔效应是研究半导体材料性能的基本方法。通过霍尔效应实验测定的霍尔系数,能够判断半导体材料的导电类型、载流子浓度及载流子迁移率等重要参数。简单原理如图1所示,半导体薄片两端通以控制电流I,垂直方向施加磁感应强度为B的匀强磁场,d为半导体材料的厚度,k为霍尔常数,它与半导体材质有关,则在垂直于电流和磁场的方向上,将产生电势差为UH的霍尔电压,它们之间的关系为。霍尔元件。

weixin_48867130的博客 1万+

caffe-源码学习——只看一篇就够了

caffe-源码学习——只看一篇就够了网络模型说caffe代码难懂,其实关键点在于caffe中有很多基础的数学运算代码,如果能够对掌握这些数学运算,剩下的就是推公式了。激活函数sigmoid看softmax函数之前先看一下简单的sigmoid, 这个sigmoid layer的cpp实现是非常简洁的。 sigmoid的cpp文件里主要给了三个函数的实现,分别是sigmoid函数,forward_cp

idevede的博客 1万+

【深度学习】tensorboard中的图片放到论文中

1. 利用tensorboard中的导出数据功能 选中左上角的标签,然后选择csv格式的数据下载即可。 左边的smoothing 数值不影响导出数据的大小。 2.tensorboard 图下标签介绍: 放大 Toggle y-axis log scale:将y轴对数化 Fit domain to data:如果拖动了图片等,再重新回到原始位置 Download Current Chart as SVG 3.用下载下来的csv数据来画图 第一幅图片:训练的平均长度 fig, ax1 = plt.sub

gaocui883的博客 1万+

安卓运行exe文件_HelloWorld背后的故事!在运行exe可执行文件前到底发生了什么?...

人物介绍故事简介编写源文件 → 预编译 →编译 →汇编 → 链接一、编写源文件 源代码:二、预编译预编译输入命令g++ -o HelloWorld.i -E HelloWorld.cpp 该命令表示编译环节的第一步,也就是预编译!当然,这一步也可以被称为“编译预处理”!而这个 HelloWorld.i 即是预编译过后的文件!序号主要行为值得注意:这一步不会做出任何安全性和合法性的检查!三、编译...

weixin_39884832的博客 205

低成本实现webhook接收端[python]

Webook本质上也是API,只不过是反向调用,即前端不主动发送请求,完全由后端推送。简单来说,Webhook是一个接受HTTP POST或是GET,PUT,DELETE的URL,一个实现了Webhook的API提供商就是在当事件发生的时候会向配置的URL发送信息,与请求-响应式不同,使用Webhook可以实时接收到变化。Ps:Webhook可能会发出大量的请求,确保接受的URL不被泄露或者应用能及时处理这些请求。

锡城小凯的博客 1万+

vos如何对接okcc(保姆级教程)

1.添加账户 点击 系统->账户管理 [图片] 2.创建费率 系统->费率管理 点击添加

qq_46333281的博客 3455

人工智能教程002:主流的人工智能开源框架

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34384681的博客 453

Nginx/OpenResty目录穿越漏洞复现

Nginx/OpenResty目录穿越漏洞复现 漏洞背景: 2020年03月18日, 360CERT监测发现 openwall oss-security 邮件组披露了两枚漏洞。在特定配置下 nginx/openresty 存在 内存泄漏漏洞/目录穿越漏洞。 Nginx 是异步框架的网页服务器,也可以用作反向代理、负载平衡器和HTTP缓存。 OpenResty是一个基于nginx的Web平台,它对nginx增加LuaJIT引擎使其运行Lua脚本。 影响版本: nginx <= v1.17

小小猪的博客 1万+

opencv canny源码解析_OpenCV 研习社 系统化带学 OpenCV 4

OpenCV4OpenCV4自从去年2018年11月份发布以后,在代码运行速度、可靠性、易用性等方面指标全面碾压OpenCV之前的版本,特别是其中深度神经网络模块,大有取代OpenCV以前版本存在的传统目标检测模块的趋势,特别是其跟Tensorflow/Caffe/PyTorch/等框架的无缝集成,极大的拓展了OpenCV在边缘与端侧设备上的图像检测与识别能力。重点是如何学习,对于小白与...

weixin_39616674的博客 175

分子对接中的相互作用特征分析(目视筛查)

介绍分子对接的相互作用特征,以及如何通过这些特征进行目视筛查

recher_He1107的博客 5762

亚马逊爬虫实战:中国商家信息(电话)爬取

import os), # 保存图片的路径# 搜索关键词"keywords":["毛巾","衣服"],"product_number": 1000000000000000, # 分页获取数量# 和url一一对应 个数要一样"remarks": ["备注1"],# 以下内容非专业人员请勿更改,请找开发人员更改. 对应的是amazon_product_url_setting文件中名称.},

youbingchen的博客 1526

caffe源码深入学习1:caffe.cpp解析

距离笔者接触深度学习已经将近半年了,在这段时间中,笔者最先接触的是lenet网络,然后就学习了2015-2016年非常火爆的fast-rcnn与faster-rcnn,到最近自己利用深度学习搞事情,笔者的最大感受是,经过一些例子的实践,已经对深度学习有了大概的了解,但是离熟练上手还有很可观的距离,这时,笔者不由得想起来一句老话:read the fxxx source code。因此,笔者开始学习

jiongnima的博客 8747

【Mode】微带传输线阻抗

微带线,英文名称为 (Microstrip) 是一种常见的平面传输线,主要用于传输微波频率信号(通常在射频和微波电路重中使用)。

u011699626的博客 245

caffe源码解析

Caffe源码(十一):io.cpp 分析 目录目录 简单介绍 主要函数ReadProtoFromTextFile 函数 WriteProtoToTextFile 函数 ReadProtoFromBinaryFile 函数 WriteProtoToBinaryFile 函数 ReadImageToCVMat 函数 matchExt 函数 CVMatToDatum 函数 ReadFileT

YLH9604的专栏 898

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

caffe 源码解读(1)

caffe 源码解读 Part1 1. 基础知识 inline C++关键字,在函数声明或定义中函数返回类型前加上关键字inline,即可以把函数指定为在计算机科学中,内联函数(有时称作在线函数或编译时期展开函数)是一种编程语言结构,用来建议编译器对一些特殊函数进行内联扩展(有时称作在线扩展);也就是说建议编译器将指定的函数体插入并取代每一处调用该函数的地方(上下文),从而节省了...

攻城狮的自我修养 937

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

caffe源码深入学习5:超级详细的caffe卷积层代码解析

caffe实现的卷积层是一个功能强大完整,同时也是一个相对复杂的层,涉及conv_layer.hpp,conv_layer.cpp,base_conv_layer.hpp和base_conv_layer.cpp,请读者朋友们仔细欣赏~

jiongnima的博客 1万+

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

caffe源码解析 — solver.cpp

caffe源码解析 — solver.cpp Solver::Solver(const SolverParameter& param)  功能:构造函数  步骤:初始化两个Net类,net_和test_net_,并调用Init()函数  输入:SolverParameter类型的param  输出:无 Solver::Solver(const string& param_f

u014114990的专栏 2783

caffe编译与caffe源码分析

caffe框架 编译 caffe框架 源码分析,主要介绍初始化网络流程和相关类 caffe框架 简单的训练流程,cpu、gpu或多gpu训练 caffe框架 源码主要分析类的注册机制

wohenibdxt的博客 875

深度学习框架Caffe入门

本课程在windows下搭建CPU版本Caffe环境,便于初学者学习和调试。通过实例介绍了Caffe的的训练和预测方法以及对应的python接口,便于大家掌握Caffe常用的训练和预测方法;结合以图形化的方式介绍网络结构、训练的loss/精度变化、代码框架梳理;还涉及到项目上Caffe更高级的应用:添加python自定义层及新增一个已有的c++层;介绍了深度学习网络训练的原理,结合Caffe的前向、反向传播的实现进行验证;最后修改一个已有的网络模型,使用项目上更常用的方式进行网络训练。

caffe源码解读整理

传送门: 传送门1 传送门2 传送门3 传送门4 传送门5 传送门6 传送门7 blob解析:传送门 比较全的: 传送门 caffe权重更新: 传送门 caffe中的正则: 传送门 修改caffe.proto文件:传送门   传送门 param:传送门 backward: 传送门 caffe's cuda: 传送门 caffe 中deploy.prototxt 和tr...

jiachen0212的博客 884

【深度学习:目标检测】 py-faster-rcnn demo.py解析

转载:http://blog.csdn.net/xzzppp/article/details/52073107 对py-faster-rcnn/tools/demo.py文件的解析: 运行该文件:先cd进入到py-faster-rcnn根目录,再在命令后窗口输入: ./tools/demo.py --net myvgg 即可运行 [python]vie

荪荪的博客 6130
上一篇: 【Caffe】001 命令行参数解析
下一篇: 【Caffe】003 caffe.proto源码解析
binlearning
博客等级 码龄10年 10粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值