void SGDSolver<Dtype>::Normalize(int param_id) {
if (this->param_.iter_size() == 1) {
return;
}
// Scale gradient to counterbalance accumulation.
const vector<Blob<Dtype>*>& net_params = this->net_->learnable_params();
const Dtype accum_normalization = Dtype(1.) / this->param_.iter_size();
switch (Caffe::mode()) {
case Caffe::CPU: {
caffe_scal(net_params[param_id]->count(), accum_normalization,
net_params[param_id]->mutable_cpu_diff());
break;
}
case Caffe::GPU: {
#ifndef CPU_ONLY
if (this->device_->backend() == BACKEND_CUDA) {
#ifdef USE_CUDA
caffe_gpu_scal(net_params[param_id]->count(), accum_normalization,
net_params[param_id]->mutable_gpu_diff());
#endif // USE_CUDA
} else {
#ifdef USE_GREENTEA
greentea_gpu_scal(this->device_->id(),
net_params[param_id]->count(), accum_normalization,
(cl_mem) (net_params[param_id]->mutable_gpu_diff()),
0);
#endif // USE_GREENTEA
}
#else
NO_GPU;
#endif
break;
}
default:
LOG(FATAL)<< "Unknown caffe mode: " << Caffe::mode();
}
}
void Blob<Dtype>::scale_diff(Dtype scale_factor) {
Dtype* diff;
if (!diff_) {
return;
}
switch (diff_->head()) {
case SyncedMemory::HEAD_AT_CPU: {
diff = mutable_cpu_diff();
caffe_scal(count_, scale_factor, diff);
return;
}
case SyncedMemory::HEAD_AT_GPU:
case SyncedMemory::SYNCED: {
#ifndef CPU_ONLY
diff = mutable_gpu_diff();
if (device_->backend() == Backend::BACKEND_CUDA) {
#ifdef USE_CUDA
caffe_gpu_scal(count_, scale_factor, diff);
#endif
} else {
#ifdef USE_GREENTEA
greentea_gpu_scal(device_->id(), count_, scale_factor,
(cl_mem) diff, 0);
#endif
}
return;
#else
NO_GPU;
#endif
}
case SyncedMemory::UNINITIALIZED:
return;
default:
LOG(FATAL)<< "Unknown SyncedMemory head state: " << diff_->head();
}
}
