caffe全连接层（INNER_PRODUCT）源码注释与分析

// Copyright 2014 BVLC and contributors.
//这是全连接层的实现
#include <vector>

#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/filler.hpp"
#include "caffe/layer.hpp"
#include "caffe/vision_layers.hpp"
#include "caffe/util/math_functions.hpp"

//  主要是三个方法，setup，forward，backward
//  setup 初始化网络参数，包括了w和b
//	forward 前向传播的实现
//	backward 后向传播的实现

 //   M_ 表示的样本数
//	K_ 表示单个样本的特征长度
//	N_ 表示输出神经元的个数
namespace caffe {

template <typename Dtype>
void InnerProductLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
									 vector<Blob<Dtype>*>* top) 
{
	//若输入或输出的blob的size不为1的话输出警告
	CHECK_EQ(bottom.size(), 1) << "IP Layer takes a single blob as input.";
	CHECK_EQ(top->size(), 1) << "IP Layer takes a single blob as output.";
  
	//通过读取配置proto文件获得输出神经元的个数及是否使用偏置项
	const int num_output = this->layer_param_.inner_product_param().num_output();
	bias_term_ = this->layer_param_.inner_product_param().bias_term();
  
	// Figure out the dimensions
	M_ = bottom[0]->num();//表示样本数
	K_ = bottom[0]->count() / bottom[0]->num();//表示单个样本的特征长度，count_ = num_ * channels_ * height_ * width_;
	N_ = num_output; //全连接之后输出的神经元的个数
	(*top)[0]->Reshape(bottom[0]->num(), num_output, 1, 1);//全连接层输出的Blob维数为样本的个数*输出神经元的个数*1*1（M*N）
	
	// Check if we need to set up the weights
	if (this->blobs_.size() > 0) 
	{
		LOG(INFO) << "Skipping parameter initialization";
	} 
	else 
	{
		//如果配置文件使用偏置项，则开辟2个Blob类智能指针，否则开辟一个
		if (bias_term_) 
		{
			this->blobs_.resize(2);
		} 
		else 
		{
			this->blobs_.resize(1);
		}

    //初始化权重和偏差
		// Intialize the weight
		//vector<shared_ptr<Blob<Dtype> > > blobs_;
		//blobs_[0]指向权重矩阵，blobs_[1]指向偏置矩阵
		//因为是全链接，所以权重矩阵的维数为N_*K_
		this->blobs_[0].reset(new Blob<Dtype>(1, 1, N_, K_));//新开辟一个Blob，指针返回给blobs_[0]；
		
		// fill the weights
		//根据配置文件中的权重核（ weight_filler）的类型初始化填充权重矩阵blobs_[0];
		shared_ptr<Filler<Dtype> > weight_filler(GetFiller<Dtype>(
			this->layer_param_.inner_product_param().weight_filler()));
		weight_filler->Fill(this->blobs_[0].get());
    
		// If necessary, intiialize and fill the bias term
		//填充偏置矩阵，每个输出单元对应一个偏置，共N_个
		if (bias_term_) 
		{
			this->blobs_[1].reset(new Blob<Dtype>(1, 1, 1, N_));
			shared_ptr<Filler<Dtype> > bias_filler(GetFiller<Dtype>(
				this->layer_param_.inner_product_param().bias_filler()));
			bias_filler->Fill(this->blobs_[1].get());
		}
	}  // parameter initialization
  
	// Setting up the bias multiplier
	if (bias_term_) 
	{
		//只是把大小（size）设置了，并未申请内存
		//shared_ptr<SyncedMemory> bias_multiplier_;
		bias_multiplier_.reset(new SyncedMemory(M_ * sizeof(Dtype)));
		Dtype* bias_multiplier_data =
			reinterpret_cast<Dtype*>(bias_multiplier_->mutable_cpu_data());//返回数据在CPU里面的指针
		
		for (int i = 0; i < M_; ++i) 
		{
			bias_multiplier_data[i] = 1.;
		}
	}
}

template <typename Dtype>
//实现的功能就是 y=wx+b
//  x为输入，维度 M_*K_
//	y为输出，维度 M_*N_
//	w为权重，维度 K_*N_
//	b为偏置，维度 N_*1_
//一批次处理多个样本，在每一批次中权重矩阵与偏置矩阵是不变的
Dtype InnerProductLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
											vector<Blob<Dtype>*>* top) 
{
	const Dtype* bottom_data = bottom[0]->cpu_data();
	Dtype* top_data = (*top)[0]->mutable_cpu_data();
	const Dtype* weight = this->blobs_[0]->cpu_data();//内存中的权重矩阵是N*K
	
	//它的功能其实很直观，即C←αA×B+βC,前两个参数控制A,B是否转置
	//其中A维度是MxK，B维度是KxN，C维度为MxN
	
	//全连接层的forward包括了两步:
	//这一步表示 y←wx，或者说是y←xw'
	//bottom_data:M*K, weight:N*K, top_data:M*N
	caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, N_, K_, 
		(Dtype)1., bottom_data, weight, (Dtype)0., top_data);
   //# 这一步表示 y←y+b
	if (bias_term_) 
	{
		const Dtype* bias = this->blobs_[1]->cpu_data();

		caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, 
			(Dtype)1., reinterpret_cast<const Dtype*>(bias_multiplier_->cpu_data()),
			bias, (Dtype)1., top_data);
	}
  //所以两步连起来就等价于y=wx+b
	//处理之后矩阵的每一行代表一个样本的N个输出神经元，共M行
	return Dtype(0);
}

template <typename Dtype>
void InnerProductLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
											const bool propagate_down,
											vector<Blob<Dtype>*>* bottom) {
//data传递的是数据，diff传递的是梯度，top_diff的维度是N*M，每一列代表一个样本的error term
  const Dtype* top_diff = top[0]->cpu_diff();
  const Dtype* bottom_data = (*bottom)[0]->cpu_data();
  // Gradient with respect to weight
  //更新W
  //其中A维度是NxM，B维度是MxK，C维度为NxK
  //top_diff:M*N, bottom_data:M*K, this->blobs_[0]->mutable_cpu_diff():N*K
  //C=A'*B,this->blobs_[0]->mutable_cpu_diff()是权重梯度矩阵（N*K）
  caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, N_, K_, M_, (Dtype)1.,
      top_diff, bottom_data, (Dtype)0., this->blobs_[0]->mutable_cpu_diff());
  if (bias_term_) {
    // Gradient with respect to bias
    caffe_cpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,
        reinterpret_cast<const Dtype*>(bias_multiplier_->cpu_data()), (Dtype)0.,
        this->blobs_[1]->mutable_cpu_diff());
  }
  if (propagate_down) {
    // Gradient with respect to bottom data
    caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, K_, N_, (Dtype)1.,
        top_diff, this->blobs_[0]->cpu_data(), (Dtype)0.,
        (*bottom)[0]->mutable_cpu_diff());
  }
}

INSTANTIATE_CLASS(InnerProductLayer);

}  // namespace caffe