Can I create an Image Reconstruction Deep Neural Network?

[alphastint]

I would like to implement Variational Auto Enconding algorithm. The core of the algorithm is that it compresses the database into a two dimensional vector, than it tries to reconstruct the original image from the two parameters.
If I have an n x n x rgb image I would like a network like n x n x rgb -> 2 -> n x n x rgb. The loss function would be the norm between the original and the reconstructed image. I have tried to use

loss_mean_squared_per_channel_and_pixel

but with both the input and the label being the same image, but it does not compile.

Is there an example in dlib for image to image metric?

Thanks in advance.

[arrufat]

Without further information, it's impossible to tell you what's wrong.
Check out this example in the dlib's test code to see how to use that loss and how to set up the labels:

dlib/dlib/test/dnn.cpp

Lines 2874 to 2947 in 18927f9

	void test_loss_mean_squared_per_channel_and_pixel()
	{
	print_spinner();
	const int num_samples = 1000;
	const long num_channels = 10;
	const long dimension = 3;
	::std::vector<matrix<float>> inputs;
	::std::vector<::std::array<matrix<float>, num_channels>> labels;
	for (int i = 0; i < num_samples; ++i)
	{
	matrix<float> x = matrix_cast<float>(randm(5, dimension));
	matrix<float> w = matrix_cast<float>(randm(num_channels, 5));
	matrix<float> y = w * x;
	DLIB_CASSERT(y.nr() == num_channels);
	::std::array<matrix<float>, num_channels> y_arr;
	// convert y to an array of matrices
	for (long c = 0; c < num_channels; ++c)
	{
	y_arr[c] = rowm(y, c);
	}
	inputs.push_back(::std::move(x));
	labels.push_back(::std::move(y_arr));
	}
	const long num_outputs = num_channels * dimension;
	using net_type = loss_mean_squared_per_channel_and_pixel<num_channels,
	extract<0, num_channels, 1, dimension,
	fc<num_outputs,
	relu<bn_fc<fc<500,
	input<matrix<float>>>>>>>>;
	net_type net;
	const auto compute_error = [&inputs, &labels, &net, num_channels]()
	{
	const auto out = net(inputs);
	double error = 0.0;
	for (size_t i = 0; i < out.size(); ++i)
	{
	for (long c = 0; c < num_channels; ++c)
	{
	error += mean(squared(out[i][c] - labels[i][c]));
	}
	}
	return error / out.size() / num_channels;
	};
	const auto error_before = compute_error();
	dnn_trainer<net_type> trainer(net);
	trainer.set_learning_rate(0.1);
	trainer.set_iterations_without_progress_threshold(500);
	trainer.set_min_learning_rate(1e-6);
	trainer.set_mini_batch_size(50);
	trainer.set_max_num_epochs(100);
	trainer.train(inputs, labels);
	const auto error_after = compute_error();
	DLIB_TEST_MSG(error_after < error_before, "multi channel error increased after training");
	#if DLIB_USE_CUDA
	cuda::compute_loss_mean_squared_per_channel_and_pixel cuda_compute;
	cpu::compute_loss_mean_squared_per_channel_and_pixel cpu_compute;
	double cuda_loss, cpu_loss;
	const tensor& output_tensor = net.subnet().get_output();
	resizable_tensor cuda_grad(output_tensor), cpu_grad(output_tensor);
	cuda_compute(labels.begin(), output_tensor, cuda_grad, cuda_loss);
	cpu_compute(labels.begin(), output_tensor, cpu_grad, cpu_loss);
	DLIB_TEST(cuda_grad.size() == cpu_grad.size());
	for (size_t i = 0; i < cuda_grad.size(); ++i)
	{
	DLIB_TEST(::std::abs(*(cuda_grad.begin() + i) - *(cpu_grad.begin() + i)) < 1e-8);
	}
	const auto err = abs(cuda_loss - cpu_loss) / cpu_loss;
	DLIB_TEST_MSG(err < 1e-6, "multi channel cuda and cpu losses differ");
	#endif
	}