LabelImage RandomForestImage::predict(const RGBDImage& image,
cuv::ndarray<float, cuv::host_memory_space>* probabilities, const bool onGPU, bool useDepthImages) const {
LabelImage prediction(image.getWidth(), image.getHeight());
const LabelType numClasses = getNumClasses();
if (treeData.size() != ensemble.size()) {
throw std::runtime_error((boost::format("tree data size: %d, ensemble size: %d. histograms normalized?")
% treeData.size() % ensemble.size()).str());
}
cuv::ndarray<float, cuv::host_memory_space> hostProbabilities(
cuv::extents[numClasses][image.getHeight()][image.getWidth()],
m_predictionAllocator);
if (onGPU) {
cuv::ndarray<float, cuv::dev_memory_space> deviceProbabilities(
cuv::extents[numClasses][image.getHeight()][image.getWidth()],
m_predictionAllocator);
cudaSafeCall(cudaMemset(deviceProbabilities.ptr(), 0, static_cast<size_t>(deviceProbabilities.size() * sizeof(float))));
{
utils::Profile profile("classifyImagesGPU");
for (const boost::shared_ptr<const TreeNodes>& data : treeData) {
classifyImage(treeData.size(), deviceProbabilities, image, numClasses, data, useDepthImages);
}
}
normalizeProbabilities(deviceProbabilities);
cuv::ndarray<LabelType, cuv::dev_memory_space> output(image.getHeight(), image.getWidth(),
m_predictionAllocator);
determineMaxProbabilities(deviceProbabilities, output);
hostProbabilities = deviceProbabilities;
cuv::ndarray<LabelType, cuv::host_memory_space> outputHost(image.getHeight(), image.getWidth(),
m_predictionAllocator);
outputHost = output;
{
utils::Profile profile("setLabels");
for (int y = 0; y < image.getHeight(); ++y) {
for (int x = 0; x < image.getWidth(); ++x) {
prediction.setLabel(x, y, static_cast<LabelType>(outputHost(y, x)));
}
}
}
} else {
utils::Profile profile("classifyImagesCPU");
tbb::parallel_for(tbb::blocked_range<size_t>(0, image.getHeight()),
[&](const tbb::blocked_range<size_t>& range) {
for(size_t y = range.begin(); y != range.end(); y++) {
for(int x=0; x < image.getWidth(); x++) {
for (LabelType label = 0; label < numClasses; label++) {
hostProbabilities(label, y, x) = 0.0f;
}
for (const auto& tree : ensemble) {
const auto& t = tree->getTree();
PixelInstance pixel(&image, 0, x, y);
const auto& hist = t->classifySoft(pixel);
assert(hist.size() == numClasses);
for(LabelType label = 0; label<hist.size(); label++) {
hostProbabilities(label, y, x) += hist[label];
}
}
double sum = 0.0f;
for (LabelType label = 0; label < numClasses; label++) {
sum += hostProbabilities(label, y, x);
}
float bestProb = -1.0f;
for (LabelType label = 0; label < numClasses; label++) {
hostProbabilities(label, y, x) /= sum;
float prob = hostProbabilities(label, y, x);
if (prob > bestProb) {
prediction.setLabel(x, y, label);
bestProb = prob;
}
}
}
}
});
}
if (probabilities) {
*probabilities = hostProbabilities;
}
return prediction;
}
LabelImage RandomForestImage::improveHistograms(const RGBDImage& image, const LabelImage& labelImage, const bool onGPU, bool useDepthImages) const {
LabelImage prediction(image.getWidth(), image.getHeight());
const LabelType numClasses = getNumClasses();
if (treeData.size() != ensemble.size()) {
throw std::runtime_error((boost::format("tree data size: %d, ensemble size: %d. histograms normalized?")
% treeData.size() % ensemble.size()).str());
}
cuv::ndarray<float, cuv::host_memory_space> hostProbabilities(
cuv::extents[numClasses][image.getHeight()][image.getWidth()],
m_predictionAllocator);
//These offsets should have been used instead of traversing to the leaf again
/* cuv::ndarray<unsigned int, cuv::dev_memory_space> nodeOffsets(
cuv::extents[image.getHeight()][image.getWidth()],
m_predictionAllocator);
*/
if (onGPU) {
cuv::ndarray<float, cuv::dev_memory_space> deviceProbabilities(
cuv::extents[numClasses][image.getHeight()][image.getWidth()],
m_predictionAllocator);
cudaSafeCall(cudaMemset(deviceProbabilities.ptr(), 0, static_cast<size_t>(deviceProbabilities.size() * sizeof(float))));
{
utils::Profile profile("classifyImagesGPU");
for (const boost::shared_ptr<const TreeNodes>& data : treeData) {
classifyImage(treeData.size(), deviceProbabilities, image, numClasses, data, useDepthImages);
bool found_tree = false;
//should be change to parallel for and add lock
for (size_t treeNr = 0; treeNr < ensemble.size(); treeNr++) {
if (data->getTreeId() == ensemble[treeNr]->getId()) {
found_tree =true;
const boost::shared_ptr<RandomTree<PixelInstance, ImageFeatureFunction> >& tree = ensemble[treeNr]->getTree();
//this should have been used and done before trying to classify the images, since it doesn't change
//std::vector<size_t> leafSet;
//tree->collectLeafNodes(leafSet);
for (int y = 0; y < image.getHeight(); y++)
for (int x = 0; x < image.getWidth(); x++) {
LabelType label = labelImage.getLabel(x,y);
if (!shouldIgnoreLabel(label)) {
PixelInstance pixel(&image, label, x, y);
//This should be changed. When classifying the image, the nodeoffsets should be returned and those used directly
//instead of traversing again to the leaves. As a test, can check if the nodeoffset is the same as the one returned
//by travertoleaf
tree->setAllPixelsHistogram(pixel);
}
}
}
if (found_tree)
break;
}
}
}
}
//should also add the CPU code!
return prediction;
}