Comment routing semi randomness

[LawrenceFulton]

The comment routing used in polis is based on the deterministical weights. In a further step a comment is then chosen by those weights (https://compdemocracy.org/comment-routing/ and https://compdemocracy.org/semi-randomly/) . What is the technique used for getting the comment based of the weights? Is is just simply weighted randomness or is there anything applied to the weights, e.g. a softmax function?

[colinmegill]

The answer to this question is here: https://compdemocracy.org/Representative-Comments/

As this is a specific question, I'm going to close the discussion as answered, but would consider a more specific discussion topic. I'll update the pages to link to this one.

[metasoarous]

I think you shared the wrong link @colinmegill. We don't have the a knowledge base page corresponding to your particular question.

[metasoarous]

Thanks for asking @LawrenceFulton.

In short, we sum up all the weights, pick a random number between 0 and said sum, and then iterate through the comments, summing up all the past weights as we go, and pick the first one that surpasses the randomly selected value (the exact order of operations is slightly different due to performance optimization, but this gives you this gist easily enough). You can see the code that does this here:

polis/server/src/server.js

Lines 7134 to 7158 in 20ab1b3

	function selectProbabilistically(comments, priorities, nTotal, nRemaining) {
	// Here we go through all of the comments we might select for the user and add their priority values
	let lookup = _.reduce(
	comments,
	(o, comment) => {
	// If we like, we can use nTotal and nRemaining here to figure out how much we should emphasize the
	// priority, potentially. Maybe we end up with different classes of priorities lists for this purpose?
	// scaling this value in some way may also be helpful.
	let lookup_val = o.lastCount + (priorities[comment.tid] || 1);
	o.lookup.push([lookup_val, comment]);
	o.lastCount = lookup_val;
	return o;
	},
	{ lastCount: 0, lookup: [] }
	);
	// We arrange a random number that should fall somewhere in the range of the lookup_vals
	let randomN = Math.random() * lookup.lastCount;
	// Return the first one that has a greater lookup; could eventually replace this with something smarter
	// that does a bisectional lookup if performance becomes an issue. But I want to keep the implementation
	// simple to reason about all other things being equal.
	let result = _.find(lookup.lookup, (x) => x[0] > randomN);
	let c = result[1];
	c.randomN = randomN;
	return c;
	}

Please let us know if you have any questions.

Thanks!