caffe源码分析--Blob类

protected:
shared_ptr<SyncedMemory> data_;  //data数据，指向SyncedMemory类的智能指针
shared_ptr<SyncedMemory> diff_;   //参数更新量
shared_ptr<SyncedMemory> shape_data_;  //数据维度
vector<int> shape_;  //数据维度
int count_;    //数据量
int capacity_;  //数据量

Blob(): data_(), diff_(), count_(0), capacity_(0){}

explicit Blob(const int num, const int channels, const int height, const int width);

Blob<Dtype>::Blob(const vector<int>& shape)//一般用这个
: capacity_(0) {
Reshape(shape);
}

template <typename Dtype>
void Blob<Dtype>::Reshape(const vector<int>& shape) {
CHECK_LE(shape.size(), kMaxBlobAxes);
count_ = 1;
shape_.resize(shape.size());
if (!shape_data_ || shape_data_->size() < shape.size() * sizeof(int)) {
shape_data_.reset(new SyncedMemory(shape.size() * sizeof(int)));
}
int* shape_data = static_cast<int*>(shape_data_->mutable_cpu_data());
for (int i = 0; i < shape.size(); ++i) {
CHECK_GE(shape[i], 0);
CHECK_LE(shape[i], INT_MAX / count_) << "blob size exceeds INT_MAX";
count_ *= shape[i];
shape_[i] = shape[i];
shape_data[i] = shape[i];
}
if (count_ > capacity_) {
capacity_ = count_;
data_.reset(new SyncedMemory(capacity_ * sizeof(Dtype)));
diff_.reset(new SyncedMemory(capacity_ * sizeof(Dtype)));
}
}

  void Reshape(const BlobShape& shape);
  void ReshapeLike(const Blob& other);

inline const vector<int>& shape() const { returnshape_; }
inline int shape(int index) const {
return shape_[CanonicalAxisIndex(index)];
}
inline int num_axes() const { return shape_.size(); }
inline int count() const { return count_; }

inline int count(int start_axis, int end_axis) const {} //返回start轴到end轴的数据量，区间左闭右开

//这四个函数过时了，使用shape(i)吧
inline int num() const
inline int channels() const
inline int height() const
inline int width() const

// 返回偏移量
inline int offset(const int n, const int c = 0, const int h = 0, const int w = 0)
inline int offset(const vector<int>& indices) const //用这个

//拷贝source数据
template <typename Dtype>
void Blob<Dtype>::CopyFrom(const Blob& source, bool copy_diff, bool reshape) {
if (source.count() != count_ || source.shape() != shape_) {
if (reshape) {
ReshapeLike(source);
} else {
LOG(FATAL) << "Trying to copy blobs of different sizes.";
}
}
switch (Caffe::mode()) {
case Caffe::GPU:
if (copy_diff) {//copy_diff为真，则拷贝diff；否则拷贝data
caffe_copy(count_, source.gpu_diff(),
static_cast<Dtype*>(diff_->mutable_gpu_data()));
} else {
caffe_copy(count_, source.gpu_data(),
static_cast<Dtype*>(data_->mutable_gpu_data()));
}
break;
case Caffe::CPU:
if (copy_diff) {
caffe_copy(count_, source.cpu_diff(),
static_cast<Dtype*>(diff_->mutable_cpu_data()));
} else {
caffe_copy(count_, source.cpu_data(),
static_cast<Dtype*>(data_->mutable_cpu_data()));
}
break;
default:
LOG(FATAL) << "Unknown caffe mode.";
}
}

<pre name="code" class="cpp">//写入bolb
template <>
void Blob<double>::ToProto(BlobProto* proto, bool write_diff) const {
proto->clear_shape();
for (int i = 0; i < shape_.size(); ++i) {
proto->mutable_shape()->add_dim(shape_[i]);
}
proto->clear_double_data();
proto->clear_double_diff();
const double* data_vec = cpu_data();
for (int i = 0; i < count_; ++i) {
proto->add_double_data(data_vec[i]);
}
if (write_diff) {
const double* diff_vec = cpu_diff();
for (int i = 0; i < count_; ++i) {
proto->add_double_diff(diff_vec[i]);
}
}

//访问（取）数据
inline Dtype data_at(const int n, const int c, const int h, const int w) const
inline Dtype diff_at(const int n, const int c, const int h, const int w) const
inline Dtype data_at(const vector<int>& index) const
inline Dtype diff_at(const vector<int>& index)

inline const shared_ptr<SyncedMemory>& data() const  //return data_智能指针
inline const shared_ptr<SyncedMemory>& diff() const //return diff_智能指针

const int* Blob<Dtype>::gpu_shape() const //return (const int*)shape_data_->gpu_data()
const Dtype* Blob<Dtype>::cpu_data() const //return (const Dtype*)data_->cpu_data()
const Dtype* Blob<Dtype>::gpu_data() //return (const Dtype*)data_->gpu_data()
const Dtype* Blob<Dtype>::cpu_diff() const //return (const Dtype*)diff_->cpu_data()
const Dtype* Blob<Dtype>::gpu_diff() // return (const Dtype*)diff_->gpu_data()
Dtype* Blob<Dtype>::mutable_cpu_data() //return static_cast<Dtype*>(data_->mutable_cpu_data())
Dtype* Blob<Dtype>::mutable_gpu_data() //return static_cast<Dtype*>(data_->mutable_gpu_data())
Dtype* Blob<Dtype>::mutable_cpu_diff() // return static_cast<Dtype*>(diff_->mutable_cpu_data())
Dtype* Blob<Dtype>::mutable_gpu_diff()  //return static_cast<Dtype*>(diff_->mutable_gpu_data())

//将other的data_和diff_赋给blob
void Blob<Dtype>::ShareData(const Blob& other)
void Blob<Dtype>::ShareDiff(const Blob& other)

<pre name="code" class="cpp">//更新权重

<pre name="code" class="cpp">template <typename Dtype>
void Blob<Dtype>::Update() {
// We will perform update based on where the data is located.
switch (data_->head()) {
case SyncedMemory::HEAD_AT_CPU:
// perform computation on CPU
caffe_axpy<Dtype>(count_, Dtype(-1),
static_cast<const Dtype*>(diff_->cpu_data()),
static_cast<Dtype*>(data_->mutable_cpu_data()));
break;
case SyncedMemory::HEAD_AT_GPU:
case SyncedMemory::SYNCED:
#ifndef CPU_ONLY
// perform computation on GPU
caffe_gpu_axpy<Dtype>(count_, Dtype(-1),
static_cast<const Dtype*>(diff_->gpu_data()),
static_cast<Dtype*>(data_->mutable_gpu_data()));
#else
NO_GPU;
#endif
break;
default:
LOG(FATAL) << "Syncedmem not initialized.";
}
}

Dtype asum_data() const; //返回data的第一范数
Dtype asum_diff() const; //返回diff的第一范数
Dtype sumsq_data() const; //返回data的第二范数
Dtype sumsq_diff() const; //返回diff的第二范数
//放缩data和diff
void scale_data(Dtype scale_factor);
void scale_diff(Dtype scale_factor);

bool ShapeEquals(const BlobProto& other); //判断各维是否相等