public double CalcRMSE(PragmaLearn.Learner.BackpropNeuralNetwork net, Dataset data, int count)
{
var error = 0.0;
var c = 0;
for (int i = 0; i < count; ++i)
{
var x = Tools.rnd.Index(data.input.Count);
var p = net.Predict(data.input[x]);
var y = data.output[x];
var se = 0.0;
for (int j = 0; j < p.Length; ++j)
{
if (y[j] != -1)
{
se += (p[j] - y[j]) * (p[j] - y[j]);
c++;
}
}
error += se;
}
error /= c;
return Math.Sqrt(error);
}
public static void ExportResult(Dataset testData, BackpropNeuralNetwork net)
{
var reader = new StreamReader(Path.Combine(dataPath, "IdLookupTable.csv"));
var writer = new StreamWriter(Path.Combine(dataPath, "result.csv"));
var featureNames = new List<string>()
{
"left_eye_center_x", "left_eye_center_y",
"right_eye_center_x", "right_eye_center_y",
"left_eye_inner_corner_x", "left_eye_inner_corner_y",
"left_eye_outer_corner_x", "left_eye_outer_corner_y",
"right_eye_inner_corner_x", "right_eye_inner_corner_y",
"right_eye_outer_corner_x", "right_eye_outer_corner_y",
"left_eyebrow_inner_end_x", "left_eyebrow_inner_end_y",
"left_eyebrow_outer_end_x", "left_eyebrow_outer_end_y",
"right_eyebrow_inner_end_x", "right_eyebrow_inner_end_y",
"right_eyebrow_outer_end_x", "right_eyebrow_outer_end_y",
"nose_tip_x", "nose_tip_y",
"mouth_left_corner_x", "mouth_left_corner_y",
"mouth_right_corner_x", "mouth_right_corner_y",
"mouth_center_top_lip_x", "mouth_center_top_lip_y",
"mouth_center_bottom_lip_x", "mouth_center_bottom_lip_y"
};
var featureLookup = featureNames.Select((f, i) => new { key = f, value = i }).ToDictionary(t => t.key, t => t.value);
Console.WriteLine();
var image = -1;
var p = default(float[]);
var s = reader.ReadLine();
writer.WriteLine("RowId,Location");
int row = 1;
while((s = reader.ReadLine()) != null)
{
var v = s.Split(',');
var img = int.Parse(v[1]);
if (img != image)
{
image = img;
p = net.Predict(testData.input[image-1]);
}
var idx = featureLookup[v[2]];
var value = Tools.Clamp(p[idx] * origImgSize, 0, origImgSize);
var rl = row + "," + value;
row++;
writer.WriteLine(rl);
Console.Write(".");
}
Console.WriteLine();
reader.Dispose();
writer.Dispose();
}
static void addSample(Dataset data)
{
var input = default(float[]);
var output = default(float[]);
var count = minLineCount + Tools.rnd.Next(maxLineCount - minLineCount + 1);
var points = new List<Vec2>();
var lines = new List<LineSegment>();
for (int i = 0; i < count; ++i)
{
var l = generateRandomLine();
lines.Add(l);
points.AddRange(generatePointsOnLine(l, epsilon));
points.AddRange(generateWhiteNoise(whiteNoise));
}
var patchPointCount = 0;
var patch = default(Rectangle);
while (patchPointCount < 5)
{
patch = getRandomPatch(2 * tileSize);
using (var i_bmp = new Bitmap(size, size))
{
i_bmp.Clear(Color.Black);
foreach (var p in points)
{
var x = p.Xi;
var y = p.Yi;
if (x >= 0 && x < i_bmp.Width && y >= 0 && y < i_bmp.Height)
{
i_bmp.SetPixel(x, y, Color.White);
if (patch.Contains(p.Xi, p.Yi))
patchPointCount++;
}
}
if (patchPointCount < 5)
continue;
// Tools.Once(() => i_bmp.Save("input.png"));
using (var pbmp = i_bmp.GetPatch(patch, tileSize))
{
input = Tools.bmp_to_float(pbmp,0);
}
}
}
using (var o_bmp = new Bitmap(size, size))
{
o_bmp.Clear(Color.Black);
drawLines(lines, o_bmp);
using (var lbmp = o_bmp.GetPatch(patch, tileSize))
{
output = Tools.bmp_to_float(lbmp);
}
}
addData(input, output, data);
}
private static void addData(float[] input, float[] output, Dataset data)
{
Monitor.Enter(data);
if (data.input.Count % 1000 == 0)
Console.WriteLine("{0}", data.input.Count);
data.AddPair(input, output);
Monitor.Exit(data);
}
public static Dataset Create(int samples)
{
Dataset result = new Dataset();
Console.WriteLine("creating dataset: ");
// for (int i = 0; i < samples; ++i)
Parallel.For(0, samples, (x) =>
{
addSample(result);
});
result.VisualizeInput = (input) => Tools.float_to_bmp(input, tileSize, tileSize);
result.VisualizeOutput = (output) => Tools.float_to_bmp(output, tileSize, tileSize);
return result;
}
public static Dataset LoadResultData()
{
Dataset result = new Dataset();
var reader = new StreamReader(Path.Combine(dataPath, "test.csv"));
// ignore first line
var line = reader.ReadLine();
while ((line = reader.ReadLine()) != null)
{
var ls = line.Split(',');
int pos = 0;
var output = default(float[]);
var pic = ls.Last().Split(' ');
var img = new float[inputSize];
for (int j = 0; j < inputSize; ++j)
{
img[j] = float.Parse(pic[j]) / 255.0f;
}
var input = default(float[]);
using (var bmp = Tools.float_to_bmp(img, origImgSize, origImgSize))
{
using (var filtered = applyFilters(bmp))
{
input = Tools.bmp_to_float(filtered);
}
}
result.AddPair(input, output);
}
return result;
}
public static Dataset LoadTrainData()
{
Dataset result = new Dataset();
var net = new PragmaLearn.Learner.BackpropNeuralNetwork();
// net.Open("network.dat");
var reader = new StreamReader(Path.Combine(dataPath, "training.csv"));
// ignore first line
var line = reader.ReadLine();
while ((line = reader.ReadLine()) != null)
{
var ls = line.Split(',');
bool skipped = false;
var keypoints = new double[outputSize];
for (int i = 0; i < outputSize; ++i)
{
if (string.IsNullOrEmpty(ls[i]))
{
Console.Write(".");
keypoints[i] = -1;
// output[i] = Tools.rnd.NextDouble();
skipped = true;
// break;
}
else
{
keypoints[i] = double.Parse(ls[i]);
}
}
//if (skipped)
// continue;
var pic = ls.Last().Split(' ');
var img = new float[inputSize];
for (int j = 0; j < inputSize; ++j)
{
img[j] = float.Parse(pic[j]) / 255.0f;
}
//if (skipped)
//{
// using (var bmp = Tools.double_to_bmp(img, origImgSize, origImgSize))
// {
// using (var filtered = applyFilters(bmp))
// {
// var input = Tools.bmp_to_double(filtered);
// var p = net.Predict(input);
// for (int i = 0; i < keypoints.Length; ++i)
// {
// if (keypoints[i] == -1)
// keypoints[i] = p[i] * origImgSize;
// }
// }
// }
//}
for (int x = 0; x < 20; ++x)
{
var points = new PointF[keypoints.Length / 2];
for (int i = 0; i < keypoints.Length; i += 2)
{
points[i / 2] = new PointF((float)keypoints[i], (float)keypoints[i + 1]);
}
var input = default(float[]);
using (var bmp = Tools.float_to_bmp(img, origImgSize, origImgSize))
{
if (x != 0)
{
using (var transformed = transformRandom(bmp, points))
{
using (var filtered = applyFilters(transformed))
{
input = Tools.bmp_to_float(filtered);
}
}
}
else
{
using (var filtered = applyFilters(bmp))
{
input = Tools.bmp_to_float(filtered);
}
}
}
var output = new float[keypoints.Length];
for (int i = 0; i < points.Length; i++)
{
output[2 * i] = points[i].X != -1 ? points[i].X / origImgSize : -1;
output[2 * i + 1] = points[i].Y != -1 ? points[i].Y / origImgSize : -1;
}
result.AddPair(input, output);
}
//if (skipped)
//{
// var p = net.Predict(input);
// for (int i = 0; i < output.Length; ++i)
// {
// if (output[i] == -1)
// output[i] = p[i];
// }
//}
}
reader.Dispose();
return result;
}
public void RandomSplit(float ratio, out Dataset trainData, out Dataset testData)
{
if (ratio < 0 || ratio > 1)
throw new ArgumentException("ratio must be in [0, 1]");
trainData = new Dataset();
testData = new Dataset();
var indices = Enumerable.Range(0, input.Count).ToList();
for (int i = 0; i < input.Count; ++i)
{
var d = default(Dataset);
if (i < (int)(ratio * input.Count))
d = trainData;
else
d = testData;
var pos = Tools.rnd.Index(indices.Count);
var x = indices[pos];
indices.RemoveAt(pos);
d.AddPair(input[x], output[x]);
}
}
private void bLoadData_Click(object sender, EventArgs e)
{
resultData = KeypointData.LoadResultData();
var data = KeypointData.LoadTrainData();
data.RandomSplit(0.9f, out trainData, out testData);
var hidden = trainData.GetInputDimension();
initNet();
clonedNet = network.Clone();
}
private void train(Dataset data, int batchSize = 100, int testModulo = 250)
{
Task.Run(() =>
{
running = true;
int t = 1;
while (running)
{
Console.Write(".");
var batch = genMiniBatch(batchSize);
network.TrainMiniBatch(data, batch);
//if (network.learningRate > 0.00001)
// network.learningRate *= 0.9995;
if (t % testModulo == 0)
{
Console.WriteLine("test begin");
this.Invoke(() => test(t));
Console.WriteLine("test end");
}
t++;
}
});
}
void display(int pos, Dataset data)
{
if (clonedNet == null)
return;
var input = data.input[pos];
var s = KeypointData.imgSize;
var p = clonedNet.Predict(input);
replaceNetworkOutput(vizKeypoints(input, p));
replaceOutput(vizKeypoints(data.input[pos], data.output[pos]));
replaceInput(Tools.float_to_bmp(input, s, s));
clonedNet.sampleDown();
replaceNetworkInput(Tools.float_to_bmp(clonedNet.GetInputLayer(), s, s));
}
private void bOpenData_Click(object sender, EventArgs e)
{
trainData = new Dataset();
trainData.Open("train.data");
testData = new Dataset();
testData.Open("test.data");
resultData = new Dataset();
resultData.Open("result.data");
initNet();
Console.WriteLine("opened");
}
