numerics Namespace Reference

Provides useful wrappers around many numerical functionality, such as dealing with sparse and dense matrix / vector data. More...

Typedefs
typedef std::vector< std::pair < uint32_t, float > >	sparse_vector_t

Functions
std::vector< std::pair < uint32_t, float > >	sparsify (const cv::Mat &dense)
	Converts the input 1D cv::Mat to a sparse format, where each pair in the vector is index, value. More...
float	cos_sim (const std::vector< std::pair< uint32_t, float > > &weights0, const std::vector< std::pair< uint32_t, float > > &weights1, const std::vector< float > &idfw)
	Converts the cosine similarity between two sparse weight vectors, which are premultiplied by the relevant entries in idfw. More...
float	min_hist (const std::vector< std::pair< uint32_t, float > > &weights0, const std::vector< std::pair< uint32_t, float > > &weights1, const std::vector< float > &idfw)
	Converts the histogram intersection (min) between two sparse weight vectors, which are premultiplied by the relevant entries in idfw. More...

Detailed Description

Provides useful wrappers around many numerical functionality, such as dealing with sparse and dense matrix / vector data.

Typedef Documentation

typedef std::vector< std::pair<uint32_t, float > > numerics::sparse_vector_t

Definition at line 10 of file numerics.hpp.

Function Documentation

float numerics::cos_sim	(	const std::vector< std::pair< uint32_t, float > > &	weights0,
		const std::vector< std::pair< uint32_t, float > > &	weights1,
		const std::vector< float > &	idfw
	)

Converts the cosine similarity between two sparse weight vectors, which are premultiplied by the relevant entries in idfw.

Sample usage would be weights0 and weights1 to represent two BoW vectors, and idfw to represent a vector of inverse document frequencies.

Definition at line 13 of file numerics.cxx.

                                              {
                float ab = 0.f, a2 = 0.f, b2 = 0.f;
                for(size_t i=0, j=0; i < weights0.size() || j < weights1.size();) {
                        if(i < weights0.size() && j < weights1.size()) {
                        if (weights0[i].first == weights1[j].first) {
                                float a = weights0[i].second * idfw[weights0[i].first];
                                float b = weights1[j].second * idfw[weights1[j].first];
                                ab += a*b;
                                        a2 += a*a;
                                        b2 += b*b;
                                        i++, j++;
                        } else if (weights0[i].first < weights1[j].first) {
                                float a = weights0[i].second * idfw[weights0[i].first];
                                a2 += a*a;
                                i++;
                        } else {
                                float b = weights1[j].second * idfw[weights1[j].first];
                                b2 += b*b;
                                j++;
                        }
                } else if(i < weights0.size()) {
                        float a = weights0[i].second * idfw[weights0[i].first];
                        a2 += a*a;
                        i++;
                } else {
                        float b = weights1[j].second * idfw[weights1[j].first];
                        b2 += b*b;
                        j++;
                }
                }
                return ab / (sqrtf(a2)*sqrtf(b2));
        }

float numerics::min_hist	(	const std::vector< std::pair< uint32_t, float > > &	weights0,
		const std::vector< std::pair< uint32_t, float > > &	weights1,
		const std::vector< float > &	idfw
	)

Converts the histogram intersection (min) between two sparse weight vectors, which are premultiplied by the relevant entries in idfw.

Sample usage would be weights0 and weights1 to represent two BoW vectors, and idfw to represent a vector of inverse document frequencies.

Definition at line 48 of file numerics.cxx.

Referenced by InvertedIndex::search().

                                              {
                float a = 0.f, b = 0.f, ab = 0.f;
                for(int k=0; k<weights0.size(); k++) {
                        a += weights0[k].second*idfw[weights0[k].first];
                }
                for(int k=0; k<weights1.size(); k++) {
                        b += weights1[k].second*idfw[weights1[k].first];
                }
                for(size_t i=0, j=0; i < weights0.size() && j < weights1.size();) {
                        if(i < weights0.size() && j < weights1.size()) {
                                if (weights0[i].first == weights1[j].first) {
                                        float min_val = weights0[i].second / a;
                                        if(min_val > (weights1[j].second / b))  {
                                                min_val = weights1[j].second / b;
                                        }
                                        ab += min_val * idfw[weights0[i].first];
                                        i++, j++;
                                } else if (weights0[i].first < weights1[j].first) {
                                        i++;
                                } else {
                                        j++;
                                }
                        }
                }
                return ab;
        }

std::vector< std::pair< uint32_t, float > > numerics::sparsify

(

const cv::Mat &

dense

)

Converts the input 1D cv::Mat to a sparse format, where each pair in the vector is index, value.

This is useful for BoW features which are usually zero.

Definition at line 5 of file numerics.cxx.

Referenced by compute_bow(), compute_bow_features(), and main().

                                                                           {
                std::vector< std::pair<uint32_t, float> > sparse;
                for(int i=0; i<dense.size().area(); i++) {
                        if( dense.at<float>(i) != 0.f) sparse.push_back( std::pair<uint32_t, float>(i, dense.at<float>(i)) );
                }
                return sparse;
        }