Caffe源码-Net类（上）
2024-09-01 21:37:23
Net类简介
Net类主要处理各个Layer之间的输入输出数据和参数数据共享等的关系。由于Net类的代码较多，本次主要介绍网络初始化部分的代码。Net类在初始化的时候将各个Layer的输出blob都统一保存在变量blobs_中，利用各个层的输入输出数据在blobs_的位置，可以方便地确定层之间数据传递的关系。Net中还利用类似的方法来存储各个层之间的学习参数，管理层之间的参数共享关系。
net.cpp部分源码
template <typename Dtype>
Net<Dtype>::Net(const NetParameter& param) { //构造函数,使用NetParameter类型的变量初始化网络
Init(param);
}
//param_file: Proto类型的文本文件名
//phase: 字段,网络的一种状态(TRAIN OR TEST) //这三种设置会在StateMeetsRule()函数中详细说明
//level: 级别,网络的一种状态
//stages: 同样为网络的一种状态,phase/level/stages三种均为网络的状态,定义在NetState消息中
template <typename Dtype>
Net<Dtype>::Net(const string& param_file, Phase phase,
const int level, const vector<string>* stages) { //创建网络,并使用从param_file中读取的网络参数和三种网络状态初始化
NetParameter param;
ReadNetParamsFromTextFileOrDie(param_file, ¶m); //从ProtoTxt文件中读取网络参数(还做了些兼容旧版本的转换操作)
// Set phase, stages and level
param.mutable_state()->set_phase(phase); //设置网络状态,字段(TRAIN 或 TEST)
if (stages != NULL) {
for (int i = 0; i < stages->size(); i++) {
param.mutable_state()->add_stage((*stages)[i]); //设置网络的stage
}
}
param.mutable_state()->set_level(level); //设置网络的level
Init(param); //初始化网络
}
template <typename Dtype>
void Net<Dtype>::Init(const NetParameter& in_param) { //网络初始化
// Set phase from the state.
phase_ = in_param.state().phase(); //网络字段(TRAIN 或 TEST)
// Filter layers based on their include/exclude rules and
// the current NetState.
NetParameter filtered_param;
FilterNet(in_param, &filtered_param); //根据网络状态和layer的状态规则过滤部分layer,得到过滤后的网络参数
LOG_IF(INFO, Caffe::root_solver()) << "Initializing net from parameters: " << std::endl
<< filtered_param.DebugString();
// Create a copy of filtered_param with splits added where necessary.
NetParameter param;
InsertSplits(filtered_param, ¶m); //将filtered_param复制到param,并拆分其中一些复用的blob数据,参见insert_splits.cpp
// Basically, build all the layers and set up their connections.
name_ = param.name(); //设置网络的名称
map<string, int> blob_name_to_idx; //<输出blob的名称, blob在blobs_中的索引>,只会保存输出blob的映射关系
//AppendBottom()会从中删除已被用作输入的输出blob,而AppendTop()会将layer的输出blob都加入其中.
//最终剩下的blob都认为是网络的输出,例如loss层的输出blob
set<string> available_blobs; //当前还未被当作输入的所有输出blob
memory_used_ = 0; //内存使用大小,初始化为0
// For each layer, set up its input and output
bottom_vecs_.resize(param.layer_size()); //初始化net中各项参数的大小,layer的个数
top_vecs_.resize(param.layer_size());
bottom_id_vecs_.resize(param.layer_size());
param_id_vecs_.resize(param.layer_size());
top_id_vecs_.resize(param.layer_size());
bottom_need_backward_.resize(param.layer_size());
for (int layer_id = 0; layer_id < param.layer_size(); ++layer_id) { //网络中的各个层
// Inherit phase from net if unset.
if (!param.layer(layer_id).has_phase()) {
param.mutable_layer(layer_id)->set_phase(phase_); //当前layer未设置phase,则使用net本身的值设置
}
// Setup layer.
const LayerParameter& layer_param = param.layer(layer_id); //当前layer的参数
if (layer_param.propagate_down_size() > 0) { //设置了是否需要反向传播
CHECK_EQ(layer_param.propagate_down_size(),
layer_param.bottom_size())
<< "propagate_down param must be specified "
<< "either 0 or bottom_size times "; //检查设置的个数与layer的输入blob的个数是否相等
}
layers_.push_back(LayerRegistry<Dtype>::CreateLayer(layer_param)); //根据layer参数创建layer
layer_names_.push_back(layer_param.name()); //保存layer的名称
LOG_IF(INFO, Caffe::root_solver()) << "Creating Layer " << layer_param.name(); //主线程打印信息
bool need_backward = false; //该layer是否需要反向传播,下面会根据layer中输入blob和层的参数来决定该值
// Figure out this layer's input and output
for (int bottom_id = 0; bottom_id < layer_param.bottom_size(); ++bottom_id) { //处理层的输入blob
const int blob_id = AppendBottom(param, layer_id, bottom_id,
&available_blobs, &blob_name_to_idx); //将layer的第bottom_id个输入blob添加到param中
// If a blob needs backward, this layer should provide it.
need_backward |= blob_need_backward_[blob_id]; //如果输入blob需要反传,则所在的layer也设置成需要
}
int num_top = layer_param.top_size();
for (int top_id = 0; top_id < num_top; ++top_id) { //处理层的输出blob
AppendTop(param, layer_id, top_id, &available_blobs, &blob_name_to_idx); //将输出blob添加到net中
// Collect Input layer tops as Net inputs.
if (layer_param.type() == "Input") { //该layer为网络的数据输入层
const int blob_id = blobs_.size() - 1;
net_input_blob_indices_.push_back(blob_id); //保存该输出blob的位置
net_input_blobs_.push_back(blobs_[blob_id].get()); //保存该输出blob的指针
}
}
// If the layer specifies that AutoTopBlobs() -> true and the LayerParameter
// specified fewer than the required number (as specified by
// ExactNumTopBlobs() or MinTopBlobs()), allocate them here.
Layer<Dtype>* layer = layers_[layer_id].get();
//允许创建匿名blob.允许输出blob的个数比ExactNumTopBlobs()或者MinTopBlobs()的值小
if (layer->AutoTopBlobs()) {
const int needed_num_top =
std::max(layer->MinTopBlobs(), layer->ExactNumTopBlobs()); //需要的输出blob的个数
for (; num_top < needed_num_top; ++num_top) {
// Add "anonymous" top blobs -- do not modify available_blobs or
// blob_name_to_idx as we don't want these blobs to be usable as input
// to other layers.
//从此处来看,匿名blob不可用做其他层的输入,但会存储在blobs_中
AppendTop(param, layer_id, num_top, NULL, NULL); //添加到net中
}
}
// After this layer is connected, set it up.
layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]); //调用layer的SetUp函数,检查输入输出blob的个数,调整大小等
LOG_IF(INFO, Caffe::root_solver()) << "Setting up " << layer_names_[layer_id]; //打印
for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) {
if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) { //输出blob对应的blob_id比权重的个数大
blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + 1, Dtype(0)); //权重的个数加1,初始为0
}
blob_loss_weights_[top_id_vecs_[layer_id][top_id]] = layer->loss(top_id); //根据layer中的权重设置
LOG_IF(INFO, Caffe::root_solver())
<< "Top shape: " << top_vecs_[layer_id][top_id]->shape_string(); //打印blob的形状信息
if (layer->loss(top_id)) {
LOG_IF(INFO, Caffe::root_solver()) << " with loss weight " << layer->loss(top_id); //loss权重不为0,也打印下
}
//TODO AppendTop()中同址计算的blob指针也会重复保存在top_vecs_中,那此处内存消耗的计算重复了???
memory_used_ += top_vecs_[layer_id][top_id]->count(); //累加输出blob中数据的个数
}
LOG_IF(INFO, Caffe::root_solver())
<< "Memory required for data: " << memory_used_ * sizeof(Dtype);
const int param_size = layer_param.param_size(); //layer参数中param参数的设置的个数
const int num_param_blobs = layers_[layer_id]->blobs().size(); //layer中可学习的参数blob的个数
CHECK_LE(param_size, num_param_blobs)
<< "Too many params specified for layer " << layer_param.name(); //设置的个数需小于等于参数blob的个数
ParamSpec default_param_spec; //layer中blob参数的默认配置,例如layer参数的lr_mult_=1和decay_mult_=1等
for (int param_id = 0; param_id < num_param_blobs; ++param_id) {
const ParamSpec* param_spec = (param_id < param_size) ?
&layer_param.param(param_id) : &default_param_spec; //使用设置的训练参数,或者使用默认配置
const bool param_need_backward = param_spec->lr_mult() != 0; //学习率系数不为0,则需要反向传播
need_backward |= param_need_backward; //如果layer的参数blob需要反传,则所在的layer也设置成需要
layers_[layer_id]->set_param_propagate_down(param_id,
param_need_backward); //将参数blob是否反传保存到net的layers_中
}
for (int param_id = 0; param_id < num_param_blobs; ++param_id) {
AppendParam(param, layer_id, param_id); //将layer的参数blob添加到net中
}
// Finally, set the backward flag
//设置layer是否需要反传(layer中输入blob和参数blob中任何一个需要,则该层都需要反传)
layer_need_backward_.push_back(need_backward);
if (need_backward) {
for (int top_id = 0; top_id < top_id_vecs_[layer_id].size(); ++top_id) {
//将layer中的输出blob也设置为需要反传
blob_need_backward_[top_id_vecs_[layer_id][top_id]] = true;
}
}
}
// Go through the net backwards to determine which blobs contribute to the
// loss. We can skip backward computation for blobs that don't contribute
// to the loss.
// Also checks if all bottom blobs don't need backward computation (possible
// because the skip_propagate_down param) and so we can skip backward
// computation for the entire layer
set<string> blobs_under_loss; //参与loss计算的blob的名称的集合
set<string> blobs_skip_backp; //可跳过反向传播的blob的名称的集合
for (int layer_id = layers_.size() - 1; layer_id >= 0; --layer_id) { //从后往前判断哪些layer对网络的loss计算有贡献
bool layer_contributes_loss = false; //初始设置为无用,可跳过
bool layer_skip_propagate_down = true;
for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) {
const string& blob_name = blob_names_[top_id_vecs_[layer_id][top_id]]; //第layer_id层的第top_id个输出blob的名称
if (layers_[layer_id]->loss(top_id) ||
(blobs_under_loss.find(blob_name) != blobs_under_loss.end())) { //该输出blob权重不为0,或者在参与计算loss的集合中能找到
layer_contributes_loss = true; //输出blob有用,则该layer设置为对loss计算有用
}
if (blobs_skip_backp.find(blob_name) == blobs_skip_backp.end()) { //该输出blob不在可跳过反传的集合中
layer_skip_propagate_down = false; //设置为不可跳过
}
//layer只要有任意一个输出blob参与loss计算,同时不可跳过反传步骤,则整个layer都是此状态,不必再判断其他输出blob了
if (layer_contributes_loss && !layer_skip_propagate_down)
break; //不用再判断其他输出blob
}
// If this layer can skip backward computation, also all his bottom blobs don't need backpropagation
//如果之前layer设置了需要反传,但是此处是可跳过反传的(此处可跳过,说明该层的所有输出blob均可跳过反传,均不参与loss计算)
if (layer_need_backward_[layer_id] && layer_skip_propagate_down) {
layer_need_backward_[layer_id] = false; //有限考虑此处的设置,设置为false
for (int bottom_id = 0; bottom_id < bottom_vecs_[layer_id].size();
++bottom_id) {
bottom_need_backward_[layer_id][bottom_id] = false; //所有输入blob也设置为不需要反传
}
}
//layer的输出blob对loss的计算无用,则layer设置为不需要反传(此处只设置了layer,后续才设置了输入参数不需要)
if (!layer_contributes_loss) { layer_need_backward_[layer_id] = false; }
if (Caffe::root_solver()) { //主线程打印该层是否需要反传的信息
if (layer_need_backward_[layer_id]) {
LOG(INFO) << layer_names_[layer_id] << " needs backward computation.";
} else {
LOG(INFO) << layer_names_[layer_id]
<< " does not need backward computation.";
}
}
for (int bottom_id = 0; bottom_id < bottom_vecs_[layer_id].size(); ++bottom_id) {
if (layer_contributes_loss) { //layer对loss计算有用
//把layer的所有输入blob的名称保存到blobs_under_loss中,表示与该输入blob对应的上层layer的
//输出blob也同样参与了loss的计算,保存名称方便设置这些上层layer的输出blob
const string& blob_name = blob_names_[bottom_id_vecs_[layer_id][bottom_id]];
blobs_under_loss.insert(blob_name);
} else {
bottom_need_backward_[layer_id][bottom_id] = false; //否则,设置输入blob为不需要反传
}
if (!bottom_need_backward_[layer_id][bottom_id]) { //当前输入blob不需要反传
//将名称保存在blobs_skip_backp中,表示与该输入blob对应的上层layer的输出blob可以跳过反传
const string& blob_name = blob_names_[bottom_id_vecs_[layer_id][bottom_id]];
blobs_skip_backp.insert(blob_name);
}
}
}
// Handle force_backward if needed.
//如果net参数中设置了需要强制反传,则根据layer的是否设置允许强制反传再设置一遍
if (param.force_backward()) {
for (int layer_id = 0; layer_id < layers_.size(); ++layer_id) {
layer_need_backward_[layer_id] = true; //默认需要
for (int bottom_id = 0; bottom_id < bottom_need_backward_[layer_id].size(); ++bottom_id) {
//输入blob设置了需要反传,或者该输入blob设置了允许强制反传
//参见layer.hpp,允许强制反传则优先遵从layer的强制设置,不允许的话则只考虑自身的设置
bottom_need_backward_[layer_id][bottom_id] =
bottom_need_backward_[layer_id][bottom_id] ||
layers_[layer_id]->AllowForceBackward(bottom_id);
//找到该输入blob在blobs_中的索引,并在blob_need_backward_中设置对应的值
blob_need_backward_[bottom_id_vecs_[layer_id][bottom_id]] =
blob_need_backward_[bottom_id_vecs_[layer_id][bottom_id]] ||
bottom_need_backward_[layer_id][bottom_id];
}
for (int param_id = 0; param_id < layers_[layer_id]->blobs().size(); ++param_id) {
layers_[layer_id]->set_param_propagate_down(param_id, true); //layer还是要遵守net的设置,全部置为需要反传
}
}
}
// In the end, all remaining blobs are considered output blobs.
//最后,将所有当前还未被当作输入的输出blob(保存在available_blobs中)全部认为是网络的输出
for (set<string>::iterator it = available_blobs.begin();
it != available_blobs.end(); ++it) { //available_blobs中剩余的blob
LOG_IF(INFO, Caffe::root_solver())
<< "This network produces output " << *it; //打印信息
net_output_blobs_.push_back(blobs_[blob_name_to_idx[*it]].get()); //将这些输出blob在blobs_中的指针统一保存起来
net_output_blob_indices_.push_back(blob_name_to_idx[*it]); //保存在blobs_中的索引
}
for (size_t blob_id = 0; blob_id < blob_names_.size(); ++blob_id) {
blob_names_index_[blob_names_[blob_id]] = blob_id; //关联blob名称和在blobs_中的索引,方便由名称得到位置
}
for (size_t layer_id = 0; layer_id < layer_names_.size(); ++layer_id) {
layer_names_index_[layer_names_[layer_id]] = layer_id; //关联layer的名称和在layers_的索引,方便由名称得到位置
}
ShareWeights(); //设置共享参数的数据和梯度指针
debug_info_ = param.debug_info(); //是否计算和打印调试信息
LOG_IF(INFO, Caffe::root_solver()) << "Network initialization done."; //网路初始化完成
}
//根据网络设置的NetState类型状态和各层内部设置的NetStateRule,判断网络是否需要包含该层
//过滤掉这些层之后得到新的网络参数param_filtered
template <typename Dtype>
void Net<Dtype>::FilterNet(const NetParameter& param,
NetParameter* param_filtered) {
NetState net_state(param.state()); //读取网络的状态
param_filtered->CopyFrom(param); //先从param中拷贝所有数据
param_filtered->clear_layer(); //然后清空所有layer
for (int i = 0; i < param.layer_size(); ++i) { //所有layer一个一个进行判断
const LayerParameter& layer_param = param.layer(i); //当前layer的参数(LayerParameter类型的消息)
const string& layer_name = layer_param.name(); //layer的名称
//检查,include和exclude不能同时设置,参见caffe.proto中的LayerParameter
//include和exclude均为NetStateRule类型的消息,用于设置layer的状态
CHECK(layer_param.include_size() == 0 || layer_param.exclude_size() == 0)
<< "Specify either include rules or exclude rules; not both.";
// If no include rules are specified, the layer is included by default and
// only excluded if it meets one of the exclude rules.
bool layer_included = (layer_param.include_size() == 0); //不包含included消息 //include和exclude都不设置时默认包含该层
for (int j = 0; layer_included && j < layer_param.exclude_size(); ++j) {
if (StateMeetsRule(net_state, layer_param.exclude(j), layer_name)) { //检查网络参数是否满足layer的exclude参数的要求
layer_included = false; //满足layer设置的任意一个exclude,则net运行时不能包含该层layer
}
}
for (int j = 0; !layer_included && j < layer_param.include_size(); ++j) {
if (StateMeetsRule(net_state, layer_param.include(j), layer_name)) {
layer_included = true; //满足layer设置的任意一个included,则net运行时需要包含该层layer
}
}
if (layer_included) {
param_filtered->add_layer()->CopyFrom(layer_param); //将该层的参数加入到网络参数中
}
}
}
//检查state(NetParameter中的参数)中的设置是否满足rule(LayerParameter中的参数)中的所有规则
//网络的phase必须与layer的phase相同,网络的level必须在layer的min_level和max_level之间
//网络的stage必须包含layer的所有stage字符串,不能包含not_stage中的任意一个字符串,这些都满足才说明网络的设置满足layer的要求
template <typename Dtype>
bool Net<Dtype>::StateMeetsRule(const NetState& state,
const NetStateRule& rule, const string& layer_name) {
// Check whether the rule is broken due to phase.
if (rule.has_phase()) { //rule中设置了phase,那么state中的字段必须与之相等才符合
if (rule.phase() != state.phase()) {
LOG_IF(INFO, Caffe::root_solver())
<< "The NetState phase (" << state.phase()
<< ") differed from the phase (" << rule.phase()
<< ") specified by a rule in layer " << layer_name; //不等,记录信息
return false;
}
}
// Check whether the rule is broken due to min level.
if (rule.has_min_level()) { //state中的level必须大于rule中设置的最小level
if (state.level() < rule.min_level()) {
LOG_IF(INFO, Caffe::root_solver())
<< "The NetState level (" << state.level()
<< ") is above the min_level (" << rule.min_level()
<< ") specified by a rule in layer " << layer_name; //不满足,记录信息
return false;
}
}
// Check whether the rule is broken due to max level.
if (rule.has_max_level()) { //state中的level必须小于rule中设置的最大level
if (state.level() > rule.max_level()) {
LOG_IF(INFO, Caffe::root_solver())
<< "The NetState level (" << state.level()
<< ") is above the max_level (" << rule.max_level()
<< ") specified by a rule in layer " << layer_name;
return false;
}
}
// Check whether the rule is broken due to stage. The NetState must
// contain ALL of the rule's stages to meet it.
for (int i = 0; i < rule.stage_size(); ++i) { //rule中设置了一堆stage字符串
// Check that the NetState contains the rule's ith stage.
bool has_stage = false;
for (int j = 0; !has_stage && j < state.stage_size(); ++j) {
if (rule.stage(i) == state.stage(j)) { has_stage = true; } //检查rule.stage(i)是否在state.stage(...)中
}
if (!has_stage) { //state中必须包含rule中的所有stage,否则返回false
LOG_IF(INFO, Caffe::root_solver())
<< "The NetState did not contain stage '" << rule.stage(i)
<< "' specified by a rule in layer " << layer_name;
return false;
}
}
// Check whether the rule is broken due to not_stage. The NetState must
// contain NONE of the rule's not_stages to meet it.
for (int i = 0; i < rule.not_stage_size(); ++i) { //rule中设置了一堆not_stage字符串
// Check that the NetState contains the rule's ith not_stage.
bool has_stage = false;
for (int j = 0; !has_stage && j < state.stage_size(); ++j) {
if (rule.not_stage(i) == state.stage(j)) { has_stage = true; } //检查rule.not_stage(i)是否在state.stage(...)中
}
if (has_stage) { //state中不能包含rule中的任何一个not_stage,否则返回false
LOG_IF(INFO, Caffe::root_solver())
<< "The NetState contained a not_stage '" << rule.not_stage(i)
<< "' specified by a rule in layer " << layer_name;
return false;
}
}
return true; //全部满足
}
//根据第layer_id层的第top_id个输出blob,创建一个空的blob保存到网络参数param中的blobs_中,同址计算则不创建
//并且无论是否为同址计算,将该blob数据的指针保存到top_vecs_中,将其在blobs_中的索引保存在top_id_vecs_中
// Helper for Net::Init: add a new top blob to the net.
template <typename Dtype>
void Net<Dtype>::AppendTop(const NetParameter& param, const int layer_id,
const int top_id, set<string>* available_blobs,
map<string, int>* blob_name_to_idx) {
shared_ptr<LayerParameter> layer_param(new LayerParameter(param.layer(layer_id))); //拷贝当前layer的参数
const string& blob_name = (layer_param->top_size() > top_id) ?
layer_param->top(top_id) : "(automatic)"; //输出blob的名称,或者用"(automatic)"(匿名blob)替代
// Check if we are doing in-place computation
if (blob_name_to_idx && layer_param->bottom_size() > top_id &&
blob_name == layer_param->bottom(top_id)) { //当前输出blob的名称与对应位置的输入blob的名称相同,为同址计算
// In-place computation
LOG_IF(INFO, Caffe::root_solver())
<< layer_param->name() << " -> " << blob_name << " (in-place)"; //在主线程中打印信息
//(*blob_name_to_idx)[blob_name]为该名称对应的blob数据在blobs_中的索引
//top_vecs_中会保存第layer_id层第top_id个输出blob的指针位置,top_id_vecs_保存索引
top_vecs_[layer_id].push_back(blobs_[(*blob_name_to_idx)[blob_name]].get());
top_id_vecs_[layer_id].push_back((*blob_name_to_idx)[blob_name]);
} else if (blob_name_to_idx &&
blob_name_to_idx->find(blob_name) != blob_name_to_idx->end()) {
//blob_name_to_idx只会存储输出blob的名称和位置,此处找到同名的输出blob,说明layer的输出blob的名称设置有问题
// If we are not doing in-place computation but have duplicated blobs,
// raise an error.
LOG(FATAL) << "Top blob '" << blob_name << "' produced by multiple sources.";
} else { //基操勿六
// Normal output.
if (Caffe::root_solver()) {
LOG(INFO) << layer_param->name() << " -> " << blob_name; //主线程中打印信息
}
//出现普通的输出blob,将其信息存储到Net中
shared_ptr<Blob<Dtype> > blob_pointer(new Blob<Dtype>()); //创建一个空的blob,返回其指针
const int blob_id = blobs_.size();
blobs_.push_back(blob_pointer); //blob_id为该输出blob在blobs_中的索引,将指针存入
blob_names_.push_back(blob_name); //设置名称
blob_need_backward_.push_back(false); //初始设置为不需要反传
if (blob_name_to_idx) { (*blob_name_to_idx)[blob_name] = blob_id; } //保存名称与位置的映射关系
top_id_vecs_[layer_id].push_back(blob_id); //top_id_vecs_[layer_id][top_id]为其位置索引
top_vecs_[layer_id].push_back(blob_pointer.get()); //top_vecs_[layer_id][top_id]为其blob指针
}
//该输出blob可被后续的layer当成输入,用于AppendBottom()中
if (available_blobs) { available_blobs->insert(blob_name); }
}
//将第layer_id层的第bottom_id个输入blob加入到网络参数param中的对应layer的参数中
// Helper for Net::Init: add a new bottom blob to the net.
template <typename Dtype>
int Net<Dtype>::AppendBottom(const NetParameter& param, const int layer_id,
const int bottom_id, set<string>* available_blobs,
map<string, int>* blob_name_to_idx) {
const LayerParameter& layer_param = param.layer(layer_id); //当前层的参数
const string& blob_name = layer_param.bottom(bottom_id); //输入blob的名称
//available_blobs存放着第0至layer_id-1层的layer中所有还未被当作输入的输出blob的名称,
//在这里面找不到该层的输入blob的名称,说明该输入blob在之前层中找不到对应的输出blob,报错
if (available_blobs->find(blob_name) == available_blobs->end()) {
LOG(FATAL) << "Unknown bottom blob '" << blob_name << "' (layer '"
<< layer_param.name() << "', bottom index " << bottom_id << ")";
}
const int blob_id = (*blob_name_to_idx)[blob_name]; //名称得到其在blobs_中的索引id
LOG_IF(INFO, Caffe::root_solver()) << layer_names_[layer_id] << " <- " << blob_name; //主线程中打印信息
//每个输入blob都会调用一次AppendBottom(),所以bottom_vecs_[layer_id][bottom_id]存放着当前输入blob的指针
bottom_vecs_[layer_id].push_back(blobs_[blob_id].get()); //将其在blobs_中的数据指针保存在bottom_vecs_中
bottom_id_vecs_[layer_id].push_back(blob_id); //bottom_id_vecs_[layer_id][bottom_id]保存该输入blob在blobs_中的索引
available_blobs->erase(blob_name); //blob_name对应的输出blob已被当作输入blob,在available_blobs中删除
bool need_backward = blob_need_backward_[blob_id]; //blobs_[blob_id]是否需要反向传播
// Check if the backpropagation on bottom_id should be skipped
if (layer_param.propagate_down_size() > 0) { //该层设置了是否需要反向传播参数
need_backward = layer_param.propagate_down(bottom_id); //读取设置中第bottom_id个的值
}
//bottom_need_backward_[layer_id][bottom_id]保存该输入blob是否需要反向传播
bottom_need_backward_[layer_id].push_back(need_backward);
return blob_id; //返回该输入blob在blobs_中的位置
}
//将第layer_id层的第param_id个参数数据保存到网络中,并保存一些用于索引的值
//对于非共享的参数,还会将数据指针保存在learnable_params_中
//learnable_param_ids_保存第第layer_id层的第param_id个参数在learnable_params_的索引,共享参数保存其来源参数的索引
template <typename Dtype>
void Net<Dtype>::AppendParam(const NetParameter& param, const int layer_id,
const int param_id) {
const LayerParameter& layer_param = layers_[layer_id]->layer_param(); //layer的参数
const int param_size = layer_param.param_size(); //layer参数中param参数的设置的个数
//按照caffe.proto文件中ParamSpec消息的说明,当需要在layer之间共享参数时,可以param_name会是一个非空的名称
string param_name =
(param_size > param_id) ? layer_param.param(param_id).name() : ""; //参数blob的名称或者默认的""
if (param_name.size()) {
param_display_names_.push_back(param_name); //非空,保存其名称,方便其他layer查询
} else {
ostringstream param_display_name;
param_display_name << param_id;
param_display_names_.push_back(param_display_name.str()); //使用param_id作为其名称
}
const int net_param_id = params_.size(); //net_param_id为当前参数在net的params_中的索引
params_.push_back(layers_[layer_id]->blobs()[param_id]); //将第layer_id层的第param_id个参数数据保存在params_中
param_id_vecs_[layer_id].push_back(net_param_id); //param_id_vecs_[layer_id][param_id]为在params_中的索引net_param_id
//param_layer_indices_[net_param_id]为参数在网络中的位置(layer_id, param_id)
param_layer_indices_.push_back(make_pair(layer_id, param_id));
ParamSpec default_param_spec; //layer中blob参数的默认训练参数,lr_mult_=1和decay_mult_=1等
const ParamSpec* param_spec = (layer_param.param_size() > param_id) ?
&layer_param.param(param_id) : &default_param_spec; //使用设置的或者默认配置
if (!param_size || !param_name.size() || (param_name.size() &&
param_names_index_.find(param_name) == param_names_index_.end())) {
//layer中没有配置param参数,或者param参数中没有设置名称,或者设置了名称但是还不在param_names_index_中
//(设置了名称但还不在param_names_index_中,说明该参数首次出现,是源参数,但是需要共享给其他的layer)
// This layer "owns" this parameter blob -- it is either anonymous
// (i.e., not given a param_name) or explicitly given a name that we
// haven't already seen.
param_owners_.push_back(-1); //参数来自自身的layer,源参数,设置为-1
if (param_name.size()) { //param中设置了名称,说明需要共享给其他layer的某个参数
param_names_index_[param_name] = net_param_id; //将参数名称param_name与在params_的位置net_param_id关联起来
}
const int learnable_param_id = learnable_params_.size(); //当前参数在learnable_params_中的索引
learnable_params_.push_back(params_[net_param_id].get()); //保存参数指针
learnable_param_ids_.push_back(learnable_param_id); //保存索引
has_params_lr_.push_back(param_spec->has_lr_mult()); //保存参数是否设置了对应的学习率系数
has_params_decay_.push_back(param_spec->has_decay_mult()); //保存参数是否设置了对应的衰减率系数
params_lr_.push_back(param_spec->lr_mult()); //保存参数的学习率系数
params_weight_decay_.push_back(param_spec->decay_mult()); //保存参数的衰减率系数
} else {
//说明该参数来源于其他的layer参数,为共享参数
//共享参数配置的param中的name必须与源参数的param中的name相同
// Named param blob with name we've seen before: share params
const int owner_net_param_id = param_names_index_[param_name]; //先找到源参数在net的params_的索引
param_owners_.push_back(owner_net_param_id); //保存源参数的索引
const pair<int, int>& owner_index =
param_layer_indices_[owner_net_param_id]; //得到源参数在网络中的位置(layer_id, param_id)
const int owner_layer_id = owner_index.first; //源参数所在的层
const int owner_param_id = owner_index.second; //源参数所在的位置
LOG_IF(INFO, Caffe::root_solver()) << "Sharing parameters '" << param_name
<< "' owned by "
<< "layer '" << layer_names_[owner_layer_id] << "', param "
<< "index " << owner_param_id; //打印信息
Blob<Dtype>* this_blob = layers_[layer_id]->blobs()[param_id].get(); //当前参数的blob指针,第layer_id层第param_id个
Blob<Dtype>* owner_blob =
layers_[owner_layer_id]->blobs()[owner_param_id].get(); //源参数在net中的blob指针,第owner_layer_id层第owner_param_id个
const int param_size = layer_param.param_size();
if (param_size > param_id && (layer_param.param(param_id).share_mode() ==
ParamSpec_DimCheckMode_PERMISSIVE)) {
//检查参数共享的模式,PERMISSIVE模式下只要求两个blob的总数据个数相同
// Permissive dimension checking -- only check counts are the same.
CHECK_EQ(this_blob->count(), owner_blob->count())
<< "Cannot share param '" << param_name << "' owned by layer '"
<< layer_names_[owner_layer_id] << "' with layer '"
<< layer_names_[layer_id] << "'; count mismatch. Owner layer param "
<< "shape is " << owner_blob->shape_string() << "; sharing layer "
<< "shape is " << this_blob->shape_string(); //检查数据的总个数是否相等
} else {
//STRICT模式下要求两个参数blob的数据的各个维度值都相等
// Strict dimension checking -- all dims must be the same.
CHECK(this_blob->shape() == owner_blob->shape())
<< "Cannot share param '" << param_name << "' owned by layer '"
<< layer_names_[owner_layer_id] << "' with layer '"
<< layer_names_[layer_id] << "'; shape mismatch. Owner layer param "
<< "shape is " << owner_blob->shape_string() << "; sharing layer "
<< "expects shape " << this_blob->shape_string(); //检查形状是否相同
}
//owner_net_param_id虽然是源参数在params_的索引,但是每次调用AppendParam()时,params_与learnable_param_ids_
//都会存入一个值,他们的大小一致,是逐个对应的(注意learnable_params_与params_不是),所以他们之间的索引可以通用
const int learnable_param_id = learnable_param_ids_[owner_net_param_id]; //得到参数在learnable_params_中的索引
learnable_param_ids_.push_back(learnable_param_id); //将源参数的索引当成当前的共享参数的索引,保存起来
if (param_spec->has_lr_mult()) { //当前的共享参数配置的param中有设置学习率系数
if (has_params_lr_[learnable_param_id]) { //源参数也配置了学习率系数
CHECK_EQ(param_spec->lr_mult(), params_lr_[learnable_param_id])
<< "Shared param '" << param_name << "' has mismatched lr_mult."; //要求两者相等,不然参数共享时更新的步长不一致
} else {
has_params_lr_[learnable_param_id] = true; //源参数未设置,则将共享参数的设置保存到源参数的设置中
params_lr_[learnable_param_id] = param_spec->lr_mult();
}
}
if (param_spec->has_decay_mult()) { //权重衰减系数同样处理
if (has_params_decay_[learnable_param_id]) {
CHECK_EQ(param_spec->decay_mult(),
params_weight_decay_[learnable_param_id])
<< "Shared param '" << param_name << "' has mismatched decay_mult."; //要求相等
} else {
has_params_decay_[learnable_param_id] = true;
params_weight_decay_[learnable_param_id] = param_spec->decay_mult(); //配置之前未设置的源参数
}
}
}
}
net.hpp源码
/// @brief The network name
string name_; //网络的名称
/// @brief The phase: TRAIN or TEST
Phase phase_; //网络的字段状态(TRAIN or TEST)
/// @brief Individual layers in the net
vector<shared_ptr<Layer<Dtype> > > layers_; //网络的各个层,layers_[layer_id]
vector<string> layer_names_; //网络的各个层的名称
map<string, int> layer_names_index_; //<layer的名称layer_name, layer在layers_中的索引layer_id>
vector<bool> layer_need_backward_; //网络的各个层是否需要反向传播
/// @brief the blobs storing intermediate results between the layer.
vector<shared_ptr<Blob<Dtype> > > blobs_; //存储网络的所有输出blob,blobs_[blob_id]
vector<string> blob_names_; //blob_names_[blob_id]为blobs_[blob_id]存储的blob数据的名称
map<string, int> blob_names_index_; //<blob数据的名称blob_name, blob数据在blobs_中的索引blob_id>
vector<bool> blob_need_backward_; //blobs_中的各个数据是否需要反向传播
/// bottom_vecs stores the vectors containing the input for each layer.
/// They don't actually host the blobs (blobs_ does), so we simply store
/// pointers.
vector<vector<Blob<Dtype>*> > bottom_vecs_; //bottom_vecs_[i][j]为第i层第j个输入blob数据的指针,数据在blobs_中
vector<vector<int> > bottom_id_vecs_; //bottom_id_vecs_[i][j]为第i层第j个输入blob在blobs_中的索引blob_id
vector<vector<bool> > bottom_need_backward_; //bottom_need_backward_[i][j]为第i层第j个输入blob是否需要反传
/// top_vecs stores the vectors containing the output for each layer
vector<vector<Blob<Dtype>*> > top_vecs_; //top_vecs_[i][j]为第i层第j个输出blob数据的指针,数据在blobs_中
vector<vector<int> > top_id_vecs_; //top_id_vecs_[i][j]为第i层第j个输出blob在blobs_中的索引blob_id
/// Vector of weight in the loss (or objective) function of each net blob, indexed by blob_id.
vector<Dtype> blob_loss_weights_; //blobs_[blob_id]对应的loss权重
vector<vector<int> > param_id_vecs_; //param_id_vecs_[i][j]为第i层第j个参数blob在params_中的位置
//param_owners_[i]为参数params_[i]的拥有者的id,源参数(参数来源于所在的layer)的值为-1,而共享参数的值为源参数在params_的索引
vector<int> param_owners_;
//param_display_names_[i]为参数params_[i]显示的名称,需共享的参数会设置非一个非空的值,未设置则用参数的id替代
//由于AppendParam()中参数名称未设置时会用param_id替代,所以该变量中可能会存在重复的名称.因此该变量不可用于寻找或匹配与共享参数同名的源参数的位置
vector<string> param_display_names_;
vector<pair<int, int> > param_layer_indices_; //param_layer_indices_[i]为参数params_[i]在网络中的位置(layer_id, param_id)
//<参数名称, 参数在params_的索引>,非空名称的参数只有在首次出现时才会保存在该变量中,后续出现都作为共享参数,所以该变量可用于寻找和匹配共享参数的源参数的位置
map<string, int> param_names_index_;
/// blob indices for the input and the output of the net
vector<int> net_input_blob_indices_; //net_input_blob_indices_[i]为网络的数据输入blob在blobs_中的索引
vector<int> net_output_blob_indices_; //net_output_blob_indices_[i]为网络的数据输出blob在blobs_中的索引
vector<Blob<Dtype>*> net_input_blobs_; //网络的数据输入blob的指针
vector<Blob<Dtype>*> net_output_blobs_; //网络的数据输出blob的指针(所有未被当作其他层输入的输出blob)
/// The parameters in the network.
vector<shared_ptr<Blob<Dtype> > > params_; //网络中的所有参数blob(包括源参数和共享参数)
vector<Blob<Dtype>*> learnable_params_; //网络中的所有学习参数,只会保存源参数
/**
* The mapping from params_ -> learnable_params_: we have
* learnable_param_ids_.size() == params_.size(),
* and learnable_params_[learnable_param_ids_[i]] == params_[i].get()
* if and only if params_[i] is an "owner"; otherwise, params_[i] is a sharer
* and learnable_params_[learnable_param_ids_[i]] gives its owner.
*/
vector<int> learnable_param_ids_; //learnable_param_ids_[i]为参数params_[i]在learnable_params_中的索引
/// the learning rate multipliers for learnable_params_
vector<float> params_lr_; //params_lr_[i]为参数learnable_params_[i]的学习率系数
vector<bool> has_params_lr_; //has_params_lr_[i]为参数learnable_params_[i]是否设置了学习率系数
/// the weight decay multipliers for learnable_params_
vector<float> params_weight_decay_; //params_weight_decay_[i]为参数learnable_params_[i]的权重衰减系数
vector<bool> has_params_decay_; //has_params_decay_[i]为参数learnable_params_[i]是否设置了权重衰减系数
/// The bytes of memory used by this net
size_t memory_used_; //网络中所有输出blob的大小之和
/// Whether to compute and display debug info for the net.
bool debug_info_; //网络是否允许计算并打印调试信息,允许的话则会打印参与前向计算的layer的输出blob和参数blob的数据的绝对值之和的均值
// Callbacks
vector<Callback*> before_forward_; //网络执行前向计算之前的回调函数
vector<Callback*> after_forward_; //网络执行前向计算之后的回调函数
vector<Callback*> before_backward_; //网络执行反向传播之前的回调函数
vector<Callback*> after_backward_; //网络执行反向传播之后的回调函数
小结
- 初始化函数中的
available_blobs，是指目前还未被当成输入blob使用的输出blob。在经过InsertSplits()操作后，除去部分被用于计算网络loss的输出blob外，剩余的输出blob与输入blob是一一对应的。所以可使用该变量快速确定某层的输入blob是否有效，以及网络的所有输出blob。 - 网络的所有输出blob都会保存在
blobs_中，网络各层之间的数据传递依赖此变量进行。但初始化的时候只会创建一个空指针，实际训练时才会将数据填充进去。 - 网络的各Layer是否需要反传，首先是根据输入数据和参数数据的设置来判断该层是否需要反传，然后是根据该层的输出数据是否参与了网络loss的计算来判断，最后是根据是否设置了强制需要反传参数来确定，越往后的判断的优先级越高。
Caffe的源码笔者是第一次阅读，一边阅读一边记录，对代码的理解和分析可能会存在错误或遗漏，希望各位读者批评指正，谢谢支持！
最新文章
- nginx用户认证配置（ Basic HTTP authentication）
- find / -name *.py | xargs grep "domain" | wc -l
- JS待定···
- 如何将jsp中<input>设为只读
- 转：Android开发中的MVP架构(最后链接资源不错)
- suds 在python3.x上的安装并访问webservice
- 如何在Xilinx ISE中使用TCL提高工作效率
- 缓存算法–LRU
- js跨域及解决方法
- YARN学习笔记（一）——YARN的简介
- 无锁atomicInteger
- win10安装mongodb及配置 和 mongodb的基本使用（node环境）
- java.sql.SQLException: **** [SQLServer]对象名 "XXXX"无效
- Kafka文件存储机制及partition和offset
- PTA——出现次数最多的数
- （转）ZooKeeper的Znode剖析
- Django之模板层-自定义过滤器以及标签
- Gen对于数组Array的处理
- Java中对文件的序列化和反序列化
- 彻底理解jdbc为什么用反射创建驱动程序对象