need a matrix example

[hqynew]

Hello,

Can you provide an example to run input with matrix, and then conduct UMAP dimenstion reduction? If possible, please also give the score results before and after the UMAP.

Many thanks!
Hong

[LTLA]

The first example in the README shows how to do run umappp with an input matrix.

[hqynew]

I use the following code:

	std::vector<double> xv_data(rows * cols);

	for (int i = 0; i < rows; i++)
	{
		for (int j = 0; j < cols; j++)
		{
			xv_data[j * rows + i] = xvector_mat(i, j);
		}
	}

	// Configuring the neighbor search algorithm; here, we'll be using an exact
	// search based on VP trees with a Cosine distance metric.
	knncolle::VptreeBuilder<int, double, double> vp_builder(
		std::make_shared<knncolle::CosineDistance<double, double> >()
	);

	// Set number of dimensions in the output embedding.
	size_t out_dim = min(32, cols - 2);
	std::vector<double> umap_embedding(rows * out_dim);

	// Initialize the UMAP state:
	umappp::Options opt;

	auto status = umappp::initialize(
		cols,
		rows,
		xv_data.data(),
		vp_builder,
		out_dim,
		umap_embedding.data(),
		opt
	);

	// Run UMAP algorithm to completion. This updates the contents
	// of the 'embedding' vector supplied to initialize().
	status.run(umap_embedding.data());

	cols = out_dim;

	xvector_mat.setDimensions(rows, cols);

	for (int i = 0; i < rows; i++)
	{
		for (int j = 0; j < cols; j++)
		{
			xvector_mat(i, j) = umap_embedding[j * rows + i];
		}
	}

---

But the new matrix after the UMAP can't work. Can anyone help check the problem?

Thanks!

[LTLA]

You'll have to be more specific. Can you create a minimum reproducible example?

[hqynew]

The following is a full example:

#include
#include
#include
#include
#include "umappp/umappp.hpp"

using namespace std;

double CosineScore(vector enroll_vector, vector trial_vector)
{
double enrollNorm, trialNorm, dotsum;
int k;

int vector_dim = enroll_vector.size();

enrollNorm = 0;
for (k = 0; k < vector_dim; k++)
    enrollNorm += enroll_vector[k] * enroll_vector[k];
enrollNorm = sqrt(enrollNorm);

trialNorm = 0;
for (k = 0; k < vector_dim; k++)
    trialNorm += trial_vector[k] * trial_vector[k];
trialNorm = sqrt(trialNorm);

dotsum = 0;
for (k = 0; k < vector_dim; k++)
    dotsum += enroll_vector[k] * trial_vector[k];

double score = dotsum / (enrollNorm * trialNorm);

return score;

}

int main() {
int rows = 20;
int cols = 10;

vector<vector<double>> matrix(rows, vector<double>(cols));
random_device rd;
mt19937 gen(rd());
normal_distribution<double> dist(0.0, 1.0);

for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        matrix[i][j] = dist(gen);
    }
}

//Cosine similarity before UMAP
cout << "Cosine similarity before UMAP: " << endl;
for (int i = 0; i < rows; i++)
{
    for (int j = i + 1; j < rows; j++)
    {
        float cosine_similarity = CosineScore(matrix[i], matrix[j]);
        cout << cosine_similarity << " ";
    }
    cout << endl;
}

// Assuming `data` contains high-dimensional data in column-major format,
// i.e., each column is a observation and each row is a dimension.
// We fill it with some random noise for the purposes of this example.
vector<double> data(rows * cols);

for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        data[j * rows + i] = matrix[i][j];
    }
}

// Configuring the neighbor search algorithm; here, we'll be using an exact
// search based on VP trees with a Cosine distance metric.
knncolle::VptreeBuilder<int, double, double> vp_builder(
    std::make_shared<knncolle::CosineDistance<double, double> >()
);

// Set number of dimensions in the output embedding.
size_t out_dim = min(32, cols - 2);
std::vector<double> umap_embedding(rows * out_dim);

// Initialize the UMAP state:
umappp::Options opt;

auto status = umappp::initialize(
    cols,
    rows,
    data.data(),
    vp_builder,
    out_dim,
    umap_embedding.data(),
    opt
);

// Run UMAP algorithm to completion. This updates the contents
// of the 'embedding' vector supplied to initialize().
status.run(umap_embedding.data());

cols = out_dim;

vector<vector<double>> umap_matrix(rows, vector<double>(cols));

for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        umap_matrix[i][j] = umap_embedding[j * rows + i];            
    }
}

//Cosine similarity after UMAP
cout << "Cosine similarity after UMAP: " << endl;
for (int i = 0; i < rows; i++)
{
    for (int j = i + 1; j < rows; j++)
    {
        float cosine_similarity = CosineScore(umap_matrix[i], umap_matrix[j]);
        cout << cosine_similarity << " ";
    }
    cout << endl;
}

return 0;

}

[LTLA]

I wish you would fix the formatting of your post.

Anyway, it doesn't look like valid C++ code, your cosineScore() function accepts vector without template arguments.

I'm not sure how I can help here, it doesn't seem like a umappp problem.

[hqynew]

So, how to measure the effectiveness of UMAP? Has it been applied to classfication task?

[LTLA]

I don't understand your question, UMAP is primarily a visualization technique.

[hqynew]

I want to use it before classification, to improve the discriminative performance of vectors.
For examples, I have 1k vectors extracted from the utterances of different speakers, and I'll make clustering to get speaker IDs. If UMAP is conducted firstly, these vectors might be clustered more prescisely.

[hqynew]

I found that Quick Start is misleading:
// Assuming data contains high-dimensional data in column-major format,
// i.e., each column is a observation and each row is a dimension.
// We fill it with some random noise for the purposes of this example.
int ndim = 10;
int nobs = 2000;
std::vector data(ndim * nobs);
std::mt19937_64 rng(1000);
std::normal_distribution ndist;
for (auto& x : data) {
x = ndist(rng);
}

Actually, it should be
// Assuming data contains high-dimensional data in row-major format,
// i.e., each row is a observation and each column is a dimension.

Therefore, my previous example should be
vector<vector> matrix(rows, vector(cols));
random_device rd;
mt19937 gen(rd());
normal_distribution dist(0.0, 1.0);

for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
matrix[i][j] = dist(gen);
}
}

//Cosine similarity before UMAP
cout << "Cosine similarity before UMAP: " << endl;
for (int i = 0; i < rows; i++)
{
for (int j = i + 1; j < rows; j++)
{
float cosine_similarity = CosineScore(matrix[i], matrix[j]);
cout << cosine_similarity << " ";
}
cout << endl;
}

// Assuming data contains high-dimensional data in column-major format,
// i.e., each column is a observation and each row is a dimension.
// We fill it with some random noise for the purposes of this example.
vector data(rows * cols);

for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
data[i * cols + j] = matrix[i][j];
}
}
.......

Now the only problem is:
size_t out_dim = min(32, cols - 2);

It might cause umappp::initialize error. When out_dim = 10, it is ok. I still can't find the reason.

[LTLA]

My example code looks correct to me. At least it's more correct than your suggestion, vector<vector> matrix(rows, vector(cols)); isn't going to work.

[hqynew]

I add PCA before UMAP, it seems ok now. No error reported.