training a net for Euclidean color distance

[leeoniya]

Hi @wpmed92,

I'd like to train a net to return a normalized color distance between two RGB pixels trained [at first] on a simple Euclidean distance with each color component being 0-255:

function colorDist(r1, g1, b1, r2, g2, b2) {
  return Math.sqrt(
    Math.pow(r2 - r1, 2) +
    Math.pow(g2 - g1, 2) +
    Math.pow(b2 - b1, 2)
  );
}

i'm normalizing the output of this function in the training set by dividing the output by the max colorDist(255,255,255,0,0,0). the training set is generated at random for 200 pixel pairs and the net topology is:

network.addLayer(new Layer(6)); //input
network.addLayer(new Layer(3, new activations.tanh())); //hidden layer
network.addLayer(new Layer(1, new activations.tanh())); //output layer

the following are tweaked from your XOR example: https://github.com/wpmed92/backpropaganda/blob/master/src/multi-layer-xor-train.js

// Train
var TRAINING_SIZE = 200;
var trainIterations = 10000
var learningRate = 0.1;
var miniBatchSize = 200;

what i'm getting as output appears pretty random and the net seems to be bucketing values into the same groups (as a classifier would) rather than returning new prediction values. i'm wondering if i would get better results by having 48 binary inputs (24 bits per px * 2 pixels) and/or and have multiple outputs?

i'm new to neural nets, so perhaps this task is not well-suited for feed-forward, or the topology or training set size needs to be massively increased?

thanks for any advice!
Leon

[wpmed92]

Hey @leeoniya !
First of all, thank you for trying out the lib! :)
Could you post a gist of your code so I can debug it and see what could be wrong?

[wpmed92]

What you could try though, is to tweak the learning rate, mini batchsize, train iterations, and you could try out other activation functions and see how they perform.

[leeoniya]

here's what i was toying with.

realistically, i'll need at least several thousand well-chosen (non-random) RGB pairs to train on. the ultimate goal is to make a fast version of color distance (delta-e) based on the perceptually-uniform CIECAM02-UCS color space that does not need to do all the rgb -> xyz -> Jab math (for speed).

i'd like to improve the color accuracy of my color quantization project. though it does pretty well in most cases, there are occasions with small palette sizes that really throw it off due to the simplistic rgb component-weighted Euclidean color distance it uses:

https://github.com/leeoniya/RgbQuant.js/blob/master/src/rgbquant.js#L703-L729

var Layer = require('./lib/layer');
var Network = require('./lib/network');
var activations = require('./lib/activations');

// https://en.wikipedia.org/wiki/Color_difference
function colorDist(r1, g1, b1, r2, g2, b2) {
	return Math.sqrt(
		Math.pow(r2 - r1, 2) +
		Math.pow(g2 - g1, 2) +
		Math.pow(b2 - b1, 2)
	);
}

let minDist = 0;
let maxDist = colorDist(255,255,255,0,0,0);

function randInt(min, max) {
	return Math.floor(Math.random() * (max - min + 1)) + min;
}

let network = new Network();

network.addLayer(new Layer(6)); //input
network.addLayer(new Layer(3, new activations.tanh())); //hidden layer
network.addLayer(new Layer(1, new activations.tanh())); //output layer

function genSet(pxPairs) {
	return pxPairs.map(p => ({
		input: p,
		output: [colorDist.apply(null, p)/maxDist]
	}));
}

const setSize = 200;

let tmpSet = Array(setSize);

for (let i = 0; i < setSize; i++)
	tmpSet[i] = [
		randInt(0,255),
		randInt(0,255),
		randInt(0,255),
		randInt(0,255),
		randInt(0,255),
		randInt(0,255),
	];

var set = genSet([
	[255,255,255,0,0,0],
	[0,0,0,0,0,0],
].concat(tmpSet));

//Init
network.setup();

//Train
var TRAINING_SIZE = setSize;
var trainIterations = 10000
var learningRate = 0.1;
var miniBatchSize = setSize;

network.train(set, TRAINING_SIZE, trainIterations, learningRate, miniBatchSize);
network.layout();

//Evaluate
for (let i = 0; i < TRAINING_SIZE; i++) {
    network.loadInput(set[i].input);
    let test = network.activate();
    console.log("Expected: " + set[i].output + ", activation: " + test);
}

network.save("deltae");

[wpmed92]

It's been a while since I worked on this project, but I remember that I played with different weight initialization techniques to decrease variance when running a network with the same parameters multiple times. I think it was the XOR problem where sometimes it solved the problem, sometimes not, which is due to the initial weights are always different. But I think in all the cases it would've solved the problem, just needed more train iterations. So a good refactor for me would be to train until the error doesn't change much, and not using hardcoded train iterations size.
So in your case part of the issue is this, but you could try out other network topologies, and other activation functions. If still no luck, maybe try another library out there.

[wpmed92]

But I'll continue working on this project, now that I see it gains some traction. :)

[wpmed92]

@leeoniya did you play with other layer structure? I tried adding more layers, tried different activation functions, but still no success. I'm not quite sure neural nets are the way to go about this.

[leeoniya]

i haven't come back to this yet, but i think that random parameter adjustment (with zero intuition) is not going to be the right way to get things working.

I'm not quite sure neural nets are the way to go about this.

perhaps feed-forward nets are not the appropriate type for this task. i'll do a bit more learning.

[wpmed92]

Ok. I searched a bit about the topic, ended up on your stackoverflow question. :D

[leeoniya]

ok, i'm having a bit more luck when quantizing the distance to 10 output groups (increments of 0.1). i think that carefully choosing the training set rather than having it be randomly generated should help a lot to make sure the network sees enough low distance, medium distance and high distance samples.

realistically, i would need at least 100 output levels and several thousand good samples to train on.

var Layer = require('./lib/layer');
var Network = require('./lib/network');
var activations = require('./lib/activations');

// https://en.wikipedia.org/wiki/Color_difference
function colorDist(r1, g1, b1, r2, g2, b2) {
	return Math.sqrt(
		Math.pow(r2 - r1, 2) +
		Math.pow(g2 - g1, 2) +
		Math.pow(b2 - b1, 2)
	);
}

let minDist = 0;
let maxDist = colorDist(1,1,1,0,0,0);

function randInt(min, max) {
	return Math.floor(Math.random() * (max - min + 1)) + min;
}

let network = new Network();

network.addLayer(new Layer(6)); //input
network.addLayer(new Layer(6, new activations.tanh())); //hidden layer
network.addLayer(new Layer(10, new activations.tanh())); //output layer

const out = [0,0,0,0,0,0,0,0,0,0];

function genSet(pxPairs) {
	return pxPairs.map(p => {
		let dist = colorDist.apply(null, p)/maxDist;
		let out2 = out.slice();

		let idx = Math.round(dist * 10);

		out2[idx] = 1;

		return {
			input: p,
			output: out2,
		}
	});
}

const setSize = 400;

let tmpSet = Array(setSize);

for (let i = 0; i < setSize; i++)
	tmpSet[i] = [
		randInt(0,255)/255,
		randInt(0,255)/255,
		randInt(0,255)/255,
		randInt(0,255)/255,
		randInt(0,255)/255,
		randInt(0,255)/255,
	];

var set = genSet([
	[1,1,1,0,0,0],
	[0,0,0,0,0,0],
].concat(tmpSet));

//Init
network.setup();

//Train
var TRAINING_SIZE = setSize;
var trainIterations = 10000
var learningRate = 0.1;
var miniBatchSize = setSize;

network.train(set, TRAINING_SIZE, trainIterations, learningRate, miniBatchSize);
network.layout();

//Evaluate
for (let i = 0; i < TRAINING_SIZE; i++) {
    network.loadInput(set[i].input);
    let test = network.activate();
    console.log("Expected: " + set[i].output + ", activation: " + test);
}

network.save("deltae");

[wpmed92]

Just ran your code, results look a lot better.