void AdaDeltaSolver<Dtype>::applyUpdate(){
CHECK(Dragon::get_root_solver());
Dtype rate = getLearningRate();
// AdaDelta do not need base lr
if (param.display() && iter%param.display() == 0)
cout << "Iteration " << iter << ", lr = AdaDelta" << endl;
clipGradients();
vector<Blob<Dtype>*> net_params = net->getLearnableParams();
for (int i = 0; i < net_params.size(); i++){
normalize(i);
regularize(i);
computeUpdateValue(i, rate);
net_params[i]->update();
}
}
//static
void GradientsHdrComposition::hdrComposition(imageListType_t const & rImageList_p,
bool bKeepLog_p,
realType_t dBias_p,
imageType_t &rResultImage_p,
numImageType_t &rDxImage_p,
numImageType_t &rDyImage_p)
{
Assert(rImageList_p.Length()>=1);
bool firstImage=true;
int nCols=0,nRows=0,nChannels=0; /// size and color space of first image
imageType_t::color_space colorSpace;
imageType_t sumImageDx, sumImageDy; /// combined gradients in x and y direction. Note: these gradients are *between* the pixels
/// of the original image, so size is one less then original image is direction of derivative
int nImages=0; /// number of images read
const int enlargeSize=1; // number of pixels added at the border
TimeMessage startHdrComposition("Gradient Domain Hdr Composition");
TimeMessage startLoadImages("Loading images");
for(std::size_t i=0;i<rImageList_p.Length();++i){
imageType_t currentImage;
int imageIndex=0;
// allow for multi-image files
while(loadFile(rImageList_p[i],imageIndex,currentImage)){
++nImages;
++imageIndex;
// expand image dimensions so I have sufficient border for morpological transform and convolution
TimeMessage startEnlarge("creating border");
currentImage.CropBy(enlargeSize,enlargeSize,enlargeSize,enlargeSize);
startEnlarge.Stop();
if(firstImage){
firstImage=false;
// determine those parameters that must be shared by all images
nCols=currentImage.Width();
nRows=currentImage.Height();
nChannels=currentImage.NumberOfChannels();
colorSpace=currentImage.ColorSpace();
//allocate necessary helper images
rDxImage_p.AllocateData(nCols,nRows,nChannels,colorSpace);
rDxImage_p.ResetSelections();
rDxImage_p.Black();
rDyImage_p.AllocateData(nCols,nRows,nChannels,colorSpace);
rDyImage_p.ResetSelections();
rDyImage_p.Black();
sumImageDx.AllocateData(nCols-1,nRows,nChannels,colorSpace);
sumImageDx.ResetSelections();
sumImageDx.Black();
sumImageDy.AllocateData(nCols,nRows-1,nChannels,colorSpace);
sumImageDy.ResetSelections();
sumImageDy.Black();
} else {
// FIXME I wonder if I should check color space etc as well...
// check if properties of this image are identical to those of the first image
if(nCols!=currentImage.Width()) {
throw Error("Current image width differs from first image width.");
} else if(nRows!=currentImage.Height()) {
throw Error("Current image height differs from first image height.");
} else if(nChannels!=currentImage.NumberOfChannels()) {
throw Error("Current image number of channels differs from first image number of channels.");
}
}
TimeMessage startProcessImage("Processing Image"+String(nImages));
hdrCompositionProcessImage(currentImage,nImages,dBias_p,0.0,1,sumImageDx, sumImageDy ,rDxImage_p,rDyImage_p);
}
}
startLoadImages.Stop();
// at this point:
// sumImageDx: max log gradient of images read in x direction
// sumImageDy: max log gradient of images read in y direction
// rSumMaskImage_p: mask with different values for the different sources of images. 0 is background.
// We use this later for information of the user, but it is not needed in the following process
TimeMessage startHdr("HDR Combining Images");
imageType_t laplaceImage;
TimeMessage startLaplace("Creating Laplace image");
// eliminate gradients that come from singularities, i.e. <=0 pixels
clipGradients(sumImageDx);
clipGradients(sumImageDy);
createLaplaceVonNeumannImage(sumImageDx,sumImageDy,laplaceImage);
startLaplace.Stop();
TimeMessage startSolve("Solving Laplace");
solveImage(laplaceImage,rResultImage_p);
startSolve.Stop();
rResultImage_p.ResetSelections();
if(!bKeepLog_p){
TimeMessage startExp("Performing Exp()");
realType_t dLogBias=std::log(1.0e-7);
rResultImage_p.Rescale(dLogBias,0.0); //assumes result range is 1e-7..1
expImage(rResultImage_p, rResultImage_p);
startExp.Stop();
}
startHdr.Stop();
#if 0
// for debugging laplaceImage
//rResultImage_p.Assign(laplaceImage);
rResultImage_p.Assign(sumImageDx);
#else
TimeMessage startEnlarge("shrinking border");
rResultImage_p.CropBy(-enlargeSize,-enlargeSize,-enlargeSize,-enlargeSize);
rDxImage_p.CropBy(-enlargeSize,-enlargeSize,-enlargeSize,-enlargeSize);
rDyImage_p.CropBy(-enlargeSize,-enlargeSize,-enlargeSize,-enlargeSize);
startEnlarge.Stop();
#endif
TimeMessage startRescale("Rescaling Result");
rResultImage_p.Rescale(); //FIXME something more clever?
startRescale.Stop();
}
