Exemple #1
0
std::vector<std::vector<int> > annTrain::getConfusionMatrix()
{
    cv::Mat testOutput;
    mlp->predict(testSamples, testOutput);
    // we now have 5 classes
    std::vector<std::vector<int> > confusionMatrix(5, std::vector<int>(5));
    for (int i = 0; i < testOutput.rows; i++)
    {
        int predictedClass = getPredictedClass(testOutput.row(i));
        int expectedClass = testOutputExpected.at(i);
        cout << expectedClass << " " << predictedClass;
        confusionMatrix[expectedClass][predictedClass]++;
    }
    return confusionMatrix;
}
Exemple #2
0
void printIndices(int k, const int classLabelLength,
		const std::shared_ptr<std::vector<util::FuzzyCluster> >& bestClusters,
		int classlabels[]) {
	util::ConfusionMatrix confusionMatrix(k, 3);
	for (int i = 0; i < classLabelLength; i++) {
		confusionMatrix.putObject(i,
				clustering::FWRDCA::getBestClusterIndex(bestClusters, i),
				classlabels[i]);
	}
	std::cout << ">>>>>>>>>>>> The F-Measure is: ";
	std::cout << confusionMatrix.fMeasureGlobal() << std::endl;
	std::cout << ">>>>>>>>>>>> The CR-Index  is: ";
	std::cout << confusionMatrix.CRIndex() << std::endl;
	std::cout << ">>>>>>>>>>>> OERC Index    is: ";
	std::cout << confusionMatrix.OERCIndex() << std::endl;
	std::cout << ">>>>>>>>>>>> NMI  Index    is: ";
	std::cout << confusionMatrix.nMIIndex() << std::endl;
	util::FuzzyIndices fuzzyIndices(bestClusters);
	for (int i = 0; i < classLabelLength; i++) {
		fuzzyIndices.insertPertinenceDegree(std::make_pair(i, i / 50), 1.0);
	}
	util::FuzzyIndices::CampelloIndices campIndices(fuzzyIndices);
	std::cout << ">>>>>>>>>>>> Campello's Rand Index            is: ";
	std::cout << campIndices.randIndex() << std::endl;
	std::cout << ">>>>>>>>>>>> Campello's Adjusted Rand Index   is: ";
	std::cout << campIndices.adjustedRandIndex() << std::endl;
	std::cout << ">>>>>>>>>>>> Campello's Jaccard Coef          is: ";
	std::cout << campIndices.jaccardCoef() << std::endl;
	std::cout << ">>>>>>>>>>>> Campello's Fowlkes-Mallows Index is: ";
	std::cout << campIndices.fowlkesMallowsIndex() << std::endl;
	std::cout << ">>>>>>>>>>>> Campello's Minkowski Measure     is: ";
	std::cout << campIndices.minkowskiMeasure() << std::endl;
	util::FuzzyIndices::AndersonIndices andIndices(fuzzyIndices);
	std::cout << ">>>>>>>>>>>> (Anderson)Fuz Rand Index Rifqi   is: ";
	std::cout << andIndices.sFRHRIndex() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Rand Index (4a)       is: ";
	std::cout << andIndices.randIndex_4a() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Johnson Index (4b)    is: ";
	std::cout << andIndices.jmcabIndex_4b() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Hubert  Index (4c)    is: ";
	std::cout << andIndices.hubertIndex_4c() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Wallace Index (4d1)   is: ";
	std::cout << andIndices.wallaceIndex_4d1() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Wallace Index (4d2)   is: ";
	std::cout << andIndices.wallaceIndex_4d2() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's FowlkesM Index (4e)   is: ";
	std::cout << andIndices.fowlkesMallow_4e() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Jacard Index (4f)     is: ";
	std::cout << andIndices.jacard_4f() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Wallace Index (4g)    is: ";
	std::cout << andIndices.adjRandHA_4g() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Adj Rand Campello(4h) is: ";
	std::cout << andIndices.adjRandCampello_4h() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Adj Rand Brower  (4i) is: ";
	std::cout << andIndices.adjRandBrouwer_4i() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Minkowski        (4j) is: ";
	std::cout << andIndices.minkowski_4j() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Hubert's Gamma   (4k) is: ";
	std::cout << andIndices.hGamma_4k() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Yule             (4l) is: ";
	std::cout << andIndices.yule_4l() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Chi-Squared      (4m) is: ";
	std::cout << andIndices.chisq_4m() << std::endl;
	std::cout << ">>>>>>>>>>>> Anderson's Goodman-Kruskal  (4n) is: ";
	std::cout << andIndices.goodmnKrkl_4n() << std::endl;
}
Exemple #3
0
void test(RandomForestImage& randomForest, const std::string& folderTesting,
        const std::string& folderPrediction, const bool useDepthFilling,
        const bool writeProbabilityImages) {

    auto filenames = listImageFilenames(folderTesting);
    if (filenames.empty()) {
        throw std::runtime_error(std::string("found no files in ") + folderTesting);
    }

    CURFIL_INFO("got " << filenames.size() << " files for prediction");

    CURFIL_INFO("label/color map:");
    const auto labelColorMap = randomForest.getLabelColorMap();
    for (const auto& labelColor : labelColorMap) {
        const auto color = LabelImage::decodeLabel(labelColor.first);
        CURFIL_INFO("label: " << static_cast<int>(labelColor.first) << ", color: RGB(" << color << ")");
    }

    tbb::mutex totalMutex;
    utils::Average averageAccuracy;
    utils::Average averageAccuracyWithoutVoid;

    const LabelType numClasses = randomForest.getNumClasses();
    ConfusionMatrix totalConfusionMatrix(numClasses);

    size_t i = 0;

    const bool useCIELab = randomForest.getConfiguration().isUseCIELab();
    CURFIL_INFO("CIELab: " << useCIELab);
    CURFIL_INFO("DepthFilling: " << useDepthFilling);

    bool onGPU = randomForest.getConfiguration().getAccelerationMode() == GPU_ONLY;

    size_t grainSize = 1;
    if (!onGPU) {
        grainSize = filenames.size();
    }

    bool writeImages = true;
    if (folderPrediction.empty()) {
        CURFIL_WARNING("no prediction folder given. will not write images");
        writeImages = false;
    }

    tbb::parallel_for(tbb::blocked_range<size_t>(0, filenames.size(), grainSize),
            [&](const tbb::blocked_range<size_t>& range) {
                for(size_t fileNr = range.begin(); fileNr != range.end(); fileNr++) {
                    const std::string& filename = filenames[fileNr];
                    const auto imageLabelPair = loadImagePair(filename, useCIELab, useDepthFilling);
                    const RGBDImage& testImage = imageLabelPair.getRGBDImage();
                    const LabelImage& groundTruth = imageLabelPair.getLabelImage();
                    LabelImage prediction(testImage.getWidth(), testImage.getHeight());

                    for(int y = 0; y < groundTruth.getHeight(); y++) {
                        for(int x = 0; x < groundTruth.getWidth(); x++) {
                            const LabelType label = groundTruth.getLabel(x, y);
                            if (label >= numClasses) {
                                const auto msg = (boost::format("illegal label in ground truth image '%s' at pixel (%d,%d): %d RGB(%3d,%3d,%3d) (numClasses: %d)")
                                        % filename
                                        % x % y
                                        % static_cast<int>(label)
                                        % LabelImage::decodeLabel(label)[0]
                                        % LabelImage::decodeLabel(label)[1]
                                        % LabelImage::decodeLabel(label)[2]
                                        % static_cast<int>(numClasses)
                                ).str();
                                throw std::runtime_error(msg);
                            }
                        }
                    }

                    boost::filesystem::path fn(testImage.getFilename());
                    const std::string basepath = folderPrediction + "/" + boost::filesystem::basename(fn);

                    cuv::ndarray<float, cuv::host_memory_space> probabilities;

                    prediction = randomForest.predict(testImage, &probabilities, onGPU);

#ifndef NDEBUG
            for(LabelType label = 0; label < randomForest.getNumClasses(); label++) {
                if (!randomForest.shouldIgnoreLabel(label)) {
                    continue;
                }

                // ignored classes must not be predicted as we did not sample them
                for(size_t y = 0; y < probabilities.shape(0); y++) {
                    for(size_t x = 0; x < probabilities.shape(1); x++) {
                        const float& probability = probabilities(label, y, x);
                        assert(probability == 0.0);
                    }
                }
            }
#endif

            if (writeImages && writeProbabilityImages) {
                utils::Profile profile("writeProbabilityImages");
                RGBDImage probabilityImage(testImage.getWidth(), testImage.getHeight());
                for(LabelType label = 0; label< randomForest.getNumClasses(); label++) {

                    if (randomForest.shouldIgnoreLabel(label)) {
                        continue;
                    }

                    for(int y = 0; y < probabilityImage.getHeight(); y++) {
                        for(int x = 0; x < probabilityImage.getWidth(); x++) {
                            const float& probability = probabilities(label, y, x);
                            for(int c=0; c<3; c++) {
                                probabilityImage.setColor(x, y, c, probability);
                            }
                        }
                    }
                    const std::string filename = (boost::format("%s_label_%d.png") % basepath % static_cast<int>(label)).str();
                    probabilityImage.saveColor(filename);
                }
            }

            int thisNumber;

            {
                tbb::mutex::scoped_lock total(totalMutex);
                thisNumber = i++;
            }

            if (writeImages) {
                utils::Profile profile("writeImages");
                testImage.saveColor(basepath + ".png");
                testImage.saveDepth(basepath + "_depth.png");
                groundTruth.save(basepath + "_ground_truth.png");
                prediction.save(basepath + "_prediction.png");
            }

            ConfusionMatrix confusionMatrix(numClasses);
            double accuracy = calculatePixelAccuracy(prediction, groundTruth, true, &confusionMatrix);
            double accuracyWithoutVoid = calculatePixelAccuracy(prediction, groundTruth, false);

            tbb::mutex::scoped_lock lock(totalMutex);

            CURFIL_INFO("prediction " << (thisNumber + 1) << "/" << filenames.size()
                    << " (" << testImage.getFilename() << "): pixel accuracy (without void): " << 100 * accuracy
                    << " (" << 100 * accuracyWithoutVoid << ")");

            averageAccuracy.addValue(accuracy);
            averageAccuracyWithoutVoid.addValue(accuracyWithoutVoid);

            totalConfusionMatrix += confusionMatrix;
        }

    });

    tbb::mutex::scoped_lock lock(totalMutex);
    double accuracy = averageAccuracy.getAverage();
    double accuracyWithoutVoid = averageAccuracyWithoutVoid.getAverage();

    totalConfusionMatrix.normalize();

    CURFIL_INFO(totalConfusionMatrix);

    CURFIL_INFO("pixel accuracy: " << 100 * accuracy);
    CURFIL_INFO("pixel accuracy without void: " << 100 * accuracyWithoutVoid);
}