private static void extract_voxel(string lfile, string rfile, string prefix)
{
int w = 1920;
int h = 1080;
int shift = 0;
int count = 0;
VideoCapture lcap = new VideoCapture(lfile);
VideoCapture rcap = new VideoCapture(rfile);
while (true)
{
Image l = LoadArgs.get_image_from_stream(lcap);
Image r = LoadArgs.get_image_from_stream(rcap);
if (l.W == 0 || r.W == 0)
{
break;
}
if (count % 100 == 0)
{
shift = LoadArgs.best_3d_shift_r(l, r, -l.H / 100, l.H / 100);
Console.Write($"{shift}\n");
}
Image ls = LoadArgs.crop_image(l, (l.W - w) / 2, (l.H - h) / 2, w, h);
Image rs = LoadArgs.crop_image(r, 105 + (r.W - w) / 2, (r.H - h) / 2 + shift, w, h);
string buff = $"{prefix}_{count:05}_l";
LoadArgs.save_image(ls, buff);
buff = $"{prefix}_{count:05}_r";
LoadArgs.save_image(rs, buff);
++count;
}
}
private static void label_classifier(string datacfg, string filename, string weightfile)
{
int i;
Network net = Parser.parse_network_cfg(filename);
Network.set_batch_network(net, 1);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
var options = OptionList.read_data_cfg(datacfg);
string labelList = OptionList.option_find_str(options, "names", "Data.Data/labels.list");
string testList = OptionList.option_find_str(options, "test", "Data.Data/train.list");
int classes = OptionList.option_find_int(options, "classes", 2);
string[] labels = Data.Data.get_labels(labelList);
string[] paths = Data.Data.GetPaths(testList);
int m = paths.Length;
for (i = 0; i < m; ++i)
{
Image im = LoadArgs.load_image_color(paths[i], 0, 0);
Image resized = LoadArgs.resize_min(im, net.W);
Image crop = LoadArgs.crop_image(resized, (resized.W - net.W) / 2, (resized.H - net.H) / 2, net.W, net.H);
float[] pred = Network.network_predict(net, crop.Data);
int ind = Utils.max_index(pred, classes);
Console.Write($"%s\n", labels[ind]);
}
}
public static void reconstruct_picture(Network net, float[] features, Image recon, Image update, float rate, float momentum, float lambda, int smoothSize, int iters)
{
int iter = 0;
for (iter = 0; iter < iters; ++iter)
{
Image delta = new Image(recon.W, recon.H, recon.C);
NetworkState state = new NetworkState();
state.Input = (float[])recon.Data.Clone();
state.Delta = (float[])delta.Data.Clone();
state.Truth = new float[Network.get_network_output_size(net)];
Array.Copy(features, 0, state.Truth, 0, state.Truth.Length);
Network.forward_network_gpu(net, state);
Network.backward_network_gpu(net, state);
Array.Copy(state.Delta, delta.Data, delta.W * delta.H * delta.C);
Blas.Axpy_cpu(recon.W * recon.H * recon.C, 1, delta.Data, update.Data);
Smooth(recon, update, lambda, smoothSize);
Blas.Axpy_cpu(recon.W * recon.H * recon.C, rate, update.Data, recon.Data);
Blas.Scal_cpu(recon.W * recon.H * recon.C, momentum, update.Data, 1);
LoadArgs.constrain_image(recon);
}
}
private static void test_cifar_csvtrain(string filename, string weightfile)
{
Network net = Parser.parse_network_cfg(filename);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Data.Data test = Data.Data.load_all_cifar10();
Matrix pred = Network.network_predict_data(net, test);
int i;
for (i = 0; i < test.X.Rows; ++i)
{
Image im = new Image(32, 32, 3, test.X.Vals[i]);
LoadArgs.flip_image(im);
}
Matrix pred2 = Network.network_predict_data(net, test);
pred.scale_matrix(.5f);
pred2.scale_matrix(.5f);
Matrix.matrix_add_matrix(pred2, pred);
pred.to_csv();
Console.Error.Write($"Accuracy: %f\n", Matrix.matrix_topk_accuracy(test.Y, pred, 1));
}
private static void test_writing(string cfgfile, string weightfile, string filename)
{
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Network.set_batch_network(net, 1);
Utils.Rand = new Random(2222222);
var sw = new Stopwatch();
string input = "";
while (true)
{
if (!string.IsNullOrEmpty(filename))
{
input = filename;
}
else
{
Console.Write($"Enter Image Path: ");
input = Console.ReadLine();
if (string.IsNullOrEmpty(input))
{
return;
}
input = input.TrimEnd();
}
Image im = LoadArgs.load_image_color(input, 0, 0);
Network.resize_network(net, im.W, im.H);
Console.Write($"%d %d %d\n", im.H, im.W, im.C);
float[] x = im.Data;
sw.Reset();
sw.Start();
Network.network_predict(net, x);
sw.Stop();
Console.Write($"%s: Predicted ini %f seconds.\n", input, sw.Elapsed.Seconds);
Image pred = Network.get_network_image(net);
Image upsampled = LoadArgs.resize_image(pred, im.W, im.H);
Image thresh = LoadArgs.threshold_image(upsampled, .5f);
pred = thresh;
LoadArgs.show_image(pred, "prediction");
LoadArgs.show_image(im, "orig");
CvInvoke.WaitKey();
CvInvoke.DestroyAllWindows();
if (!string.IsNullOrEmpty(filename))
{
break;
}
}
}
private static void demo_art(string cfgfile, string weightfile, int camIndex)
{
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Network.set_batch_network(net, 1);
Utils.Rand = new Random(2222222);
using (VideoCapture cap = new VideoCapture(camIndex))
{
string window = "ArtJudgementBot9000!!!";
if (cap != null)
{
Utils.Error("Couldn't connect to webcam.\n");
}
int i;
int[] idx = { 37, 401, 434 };
int n = idx.Length;
while (true)
{
Image ini = LoadArgs.get_image_from_stream(cap);
Image inS = LoadArgs.resize_image(ini, net.W, net.H);
LoadArgs.show_image(ini, window);
float[] p = Network.network_predict(net, inS.Data);
Console.Write($"\033[2J");
Console.Write($"\033[1;1H");
float score = 0;
for (i = 0; i < n; ++i)
{
float s = p[idx[i]];
if (s > score)
{
score = s;
}
}
Console.Write($"I APPRECIATE THIS ARTWORK: %10.7f%%\n", score * 100);
Console.Write($"[");
int upper = 30;
for (i = 0; i < upper; ++i)
{
Console.Write($"%c", ((i + .5) < score * upper) ? 219 : ' ');
}
Console.Write($"]\n");
CvInvoke.WaitKey(1);
}
}
}
private static void fetch_in_thread()
{
inputImage = LoadArgs.get_image_from_stream(vidCap);
if (inputImage.Data.Length == 0)
{
Utils.Error("Stream closed.");
}
inS = LoadArgs.resize_image(inputImage, net.W, net.H);
}
private static FloatPair get_rnn_vid_data(Network net, string[] files, int n, int batch, int steps)
{
int b;
Image outIm = Network.get_network_image(net);
int outputSize = outIm.W * outIm.H * outIm.C;
Console.Write($"%d %d %d\n", outIm.W, outIm.H, outIm.C);
float[] feats = new float[net.Batch * batch * outputSize];
for (b = 0; b < batch; ++b)
{
int inputSize = net.W * net.H * net.C;
float[] input = new float[inputSize * net.Batch];
string filename = files[Utils.Rand.Next() % n];
using (VideoCapture cap = new VideoCapture(filename))
{
int frames = (int)cap.GetCaptureProperty(CapProp.FrameCount);
int index = Utils.Rand.Next() % (frames - steps - 2);
if (frames < (steps + 4))
{
--b;
continue;
}
Console.Write($"frames: %d, index: %d\n", frames, index);
cap.SetCaptureProperty(CapProp.PosFrames, index);
int i;
for (i = 0; i < net.Batch; ++i)
{
using (Mat src = cap.QueryFrame())
{
Image im = new Image(src);
LoadArgs.rgbgr_image(im);
Image re = LoadArgs.resize_image(im, net.W, net.H);
Array.Copy(re.Data, 0, input, i * inputSize, inputSize);
}
}
float[] output = Network.network_predict(net, input);
for (i = 0; i < net.Batch; ++i)
{
Array.Copy(output, i * outputSize, feats, (b + i * batch) * outputSize, outputSize);
}
}
}
FloatPair p = new FloatPair();
p.X = feats;
p.Y = new float[feats.Length - outputSize * batch];
Array.Copy(feats, outputSize * batch, p.Y, 0, p.Y.Length);
return(p);
}
private static void optimize_picture(Network net, Image orig, int maxLayer, float scale, float rate, float thresh, bool norm)
{
net.N = maxLayer + 1;
int dx = Utils.Rand.Next() % 16 - 8;
int dy = Utils.Rand.Next() % 16 - 8;
bool flip = Utils.Rand.Next() % 2 != 0;
Image crop = LoadArgs.crop_image(orig, dx, dy, orig.W, orig.H);
Image im = LoadArgs.resize_image(crop, (int)(orig.W * scale), (int)(orig.H * scale));
if (flip)
{
LoadArgs.flip_image(im);
}
Network.resize_network(net, im.W, im.H);
Layer last = net.Layers[net.N - 1];
Image delta = new Image(im.W, im.H, im.C);
NetworkState state = new NetworkState();
state.Input = (float[])im.Data.Clone();
state.Delta = (float[])im.Data.Clone();
Network.forward_network_gpu(net, state);
Blas.copy_ongpu(last.Outputs, last.OutputGpu, last.DeltaGpu);
Array.Copy(last.DeltaGpu, last.Delta, last.Outputs);
calculate_loss(last.Delta, last.Delta, last.Outputs, thresh);
Array.Copy(last.Delta, last.DeltaGpu, last.Outputs);
Network.backward_network_gpu(net, state);
Array.Copy(state.Delta, delta.Data, im.W * im.H * im.C);
if (flip)
{
LoadArgs.flip_image(delta);
}
Image resized = LoadArgs.resize_image(delta, orig.W, orig.H);
Image outi = LoadArgs.crop_image(resized, -dx, -dy, orig.W, orig.H);
if (norm)
{
Utils.normalize_array(outi.Data, outi.W * outi.H * outi.C);
}
Blas.Axpy_cpu(orig.W * orig.H * orig.C, rate, outi.Data, orig.Data);
LoadArgs.constrain_image(orig);
}
protected virtual bool CheckArgsCorrect(IScenarioContent content, ref LoadArgs args, out string error)
{
switch (args.type)
{
case "scene":
if (string.IsNullOrEmpty(args.arg0))
{
error = string.Format(
"{0} ParseArgs error: scene name can not be null or empty.",
typeName);
return(false);
}
break;
case "profile":
if (string.IsNullOrEmpty(args.arg0))
{
error = string.Format(
"{0} ParseArgs error: profile position is null or empty.",
typeName);
return(false);
}
args.arg0 = args.arg0.ToLower();
if (args.arg0 != "top" || args.arg0 != "bottom")
{
error = string.Format(
"{0} ParseArgs error: profile position can only be one of [top, bottom].",
typeName);
return(false);
}
if (string.IsNullOrEmpty(args.arg1))
{
error = string.Format(
"{0} ParseArgs error: profile name is null or empty.",
typeName);
return(false);
}
break;
// TODO other
default:
break;
}
error = null;
return(true);
}
private static void test_coco(string cfgfile, string weightfile, string filename, float thresh)
{
Image[][] alphabet = LoadArgs.load_alphabet();
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Layer l = net.Layers[net.N - 1];
Network.set_batch_network(net, 1);
Utils.Rand = new Random(2222222);
float nms = .4f;
var sw = new Stopwatch();
int j;
Box[] boxes = new Box[l.Side * l.Side * l.N];
float[][] probs = new float[l.Side * l.Side * l.N][];
for (j = 0; j < l.Side * l.Side * l.N; ++j) probs[j] = new float[l.Classes];
while (true)
{
string input;
if (!string.IsNullOrEmpty(filename))
{
input = filename;
}
else
{
Console.Write($"Enter Image Path: ");
input = Console.ReadLine();
if (string.IsNullOrEmpty(input)) return;
input = input.TrimEnd();
}
Image im = LoadArgs.load_image_color(input, 0, 0);
Image sized = LoadArgs.resize_image(im, net.W, net.H);
float[] x = sized.Data;
sw.Reset();
sw.Start();
Network.network_predict(net, x);
sw.Stop();
Console.Write($"%s: Predicted ini %f seconds.\n", input, sw.Elapsed.Seconds);
l.get_detection_boxes( 1, 1, thresh, probs, boxes, false);
if (nms != 0) Box.do_nms_sort(boxes, probs, l.Side * l.Side * l.N, l.Classes, nms);
LoadArgs.draw_detections(im, l.Side * l.Side * l.N, thresh, boxes, probs, CocoClasses, alphabet, 80);
LoadArgs.save_image(im, "prediction");
LoadArgs.show_image(im, "predictions");
CvInvoke.WaitKey();
CvInvoke.DestroyAllWindows();
if (!string.IsNullOrEmpty(filename)) break;
}
}
private static void generate_vid_rnn(string cfgfile, string weightfile)
{
Network extractor = Parser.parse_network_cfg("cfg/extractor.recon.cfg");
Parser.load_weights(extractor, "/home/pjreddie/trained/yolo-coco.conv");
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Network.set_batch_network(extractor, 1);
Network.set_batch_network(net, 1);
int i;
VideoCapture cap = new VideoCapture("/extra/vid/ILSVRC2015/Data.Data/VID/snippets/val/ILSVRC2015_val_00007030.mp4");
float[] feat;
float[] next;
next = null;
Image last = null;
for (i = 0; i < 25; ++i)
{
Image im = LoadArgs.get_image_from_stream(cap);
Image re = LoadArgs.resize_image(im, extractor.W, extractor.H);
feat = Network.network_predict(extractor, re.Data);
if (i > 0)
{
Console.Write($"%f %f\n", Utils.mean_array(feat, 14 * 14 * 512), Utils.variance_array(feat, 14 * 14 * 512));
Console.Write($"%f %f\n", Utils.mean_array(next, 14 * 14 * 512), Utils.variance_array(next, 14 * 14 * 512));
Console.Write($"%f\n", Utils.mse_array(feat, 14 * 14 * 512));
Blas.Axpy_cpu(14 * 14 * 512, -1, feat, next);
Console.Write($"%f\n", Utils.mse_array(next, 14 * 14 * 512));
}
next = Network.network_predict(net, feat);
if (i == 24)
{
last = new Image(re);
}
}
for (i = 0; i < 30; ++i)
{
next = Network.network_predict(net, next);
Image newi = save_reconstruction(extractor, last, next, "new", i);
last = newi;
}
}
private static void test_super(string cfgfile, string weightfile, string filename)
{
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Network.set_batch_network(net, 1);
Utils.Rand = new Random(2222222);
var sw = new Stopwatch();
string input = "";
while (true)
{
if (!string.IsNullOrEmpty(filename))
{
input = filename;
}
else
{
Console.Write($"Enter Image Path: ");
input = Console.ReadLine();
if (string.IsNullOrEmpty(input))
{
return;
}
input = input.TrimEnd();
}
Image im = LoadArgs.load_image_color(input, 0, 0);
Network.resize_network(net, im.W, im.H);
Console.Write($"%d %d\n", im.W, im.H);
float[] x = im.Data;
sw.Start();
Network.network_predict(net, x);
Image outi = Network.get_network_image(net);
sw.Stop();
Console.Write($"%s: Predicted ini %f seconds.\n", input, sw.Elapsed.Seconds);
LoadArgs.save_image(outi, "outf");
if (!string.IsNullOrEmpty(filename))
{
break;
}
}
}
public override bool ParseArgs(IScenarioContent content, ref LoadArgs args, out string error)
{
if (content.length < 2)
{
error = GetLengthErrorString();
return(false);
}
args.type = content[1].ToLower();
if (!GetSupportedTypes().Contains(args.type))
{
error = string.Format(
"{0} ParseArgs -> the type `{1}` is not supported.",
typeName,
args.type);
return(false);
}
int length = content.length;
int index = 2;
if (index < length)
{
args.arg0 = content[index++];
}
if (index < length)
{
args.arg1 = content[index++];
}
if (index < length)
{
args.arg2 = content[index++];
}
if (index < length)
{
args.arg3 = content[index++];
}
return(CheckArgsCorrect(content, ref args, out error));
}
private static int bbox_comparator(SortableBbox a, SortableBbox b)
{
++TotalCompares;
Network net = a.Net;
int sclass = a.Sclass;
Image im1 = LoadArgs.load_image_color(a.Filename, net.W, net.H);
Image im2 = LoadArgs.load_image_color(b.Filename, net.W, net.H);
float[] x = new float[net.W * net.H * net.C];
Array.Copy(im1.Data, 0, x, 0, im1.Data.Length);
Array.Copy(im2.Data, 0, x, im1.Data.Length, im2.Data.Length);
float[] predictions = Network.network_predict(net, x);
if (predictions[sclass * 2] > predictions[sclass * 2 + 1])
{
return(1);
}
return(-1);
}
private static void detect_in_thread()
{
float nms = .4f;
Layer l = net.Layers[net.N - 1];
float[] x = detS.Data;
float[] prediction = Network.network_predict(net, x);
Array.Copy(prediction, 0, prediction, demoIndex, l.Outputs);
Utils.mean_arrays(predictions, frames, l.Outputs, avg);
l.Output = avg;
if (l.LayerType == LayerType.Detection)
{
l.get_detection_boxes(1, 1, demoThresh, probs, boxes, false);
}
else if (l.LayerType == LayerType.Region)
{
Layer.get_region_boxes(l, 1, 1, demoThresh, probs, boxes, false, new int[0]);
}
else
{
Utils.Error("Last Layer must produce detections\n");
}
if (nms > 0)
{
Box.do_nms(boxes, probs, l.W * l.H * l.N, l.Classes, nms);
}
Console.Write($"\033[2J");
Console.Write($"\033[1;1H");
Console.Write($"\nFPS:%.1f\n", fps);
Console.Write($"Objects:\n\n");
images[demoIndex] = det;
det = images[(demoIndex + frames / 2 + 1) % frames];
demoIndex = (demoIndex + 1) % frames;
LoadArgs.draw_detections(det, l.W * l.H * l.N, demoThresh, boxes, probs, demoNames, demoAlphabet, demoClasses);
}
private static Image save_reconstruction(Network net, Image init, float[] feat, string name, int i)
{
Image recon;
if (init != null)
{
recon = new Image(init);
}
else
{
recon = LoadArgs.make_random_image(net.W, net.H, 3);
}
Image update = new Image(net.W, net.H, 3);
Nightmare.reconstruct_picture(net, feat, recon, update, .01f, .9f, .1f, 2, 50);
string buff = $"{name}{i}";
LoadArgs.save_image(recon, buff);
return(recon);
}
private static void extract_cifar()
{
string[] labels = { "airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck" };
int i;
Data.Data train = Data.Data.load_all_cifar10();
Data.Data test = Data.Data.load_cifar10_data("Data.Data/cifar/cifar-10-batches-bin/test_batch.bin");
for (i = 0; i < train.X.Rows; ++i)
{
Image im = new Image(32, 32, 3, train.X.Vals[i]);
int sclass = Utils.max_index(train.Y.Vals[i], 10);
string buff = $"Data.Data/cifar/train/{i}_{labels[sclass]}";
LoadArgs.save_image_png(im, buff);
}
for (i = 0; i < test.X.Rows; ++i)
{
Image im = new Image(32, 32, 3, test.X.Vals[i]);
int sclass = Utils.max_index(test.Y.Vals[i], 10);
string buff = $"Data.Data/cifar/test/{i}_{labels[sclass]}";
LoadArgs.save_image_png(im, buff);
}
}
private static void bbox_fight(Network net, SortableBbox a, SortableBbox b, int classes, int sclass)
{
Image im1 = LoadArgs.load_image_color(a.Filename, net.W, net.H);
Image im2 = LoadArgs.load_image_color(b.Filename, net.W, net.H);
float[] x = new float[net.W * net.H * net.C];
Array.Copy(im1.Data, 0, x, 0, im1.Data.Length);
Array.Copy(im2.Data, 0, x, im1.Data.Length, im2.Data.Length);
float[] predictions = Network.network_predict(net, x);
++TotalCompares;
int i;
for (i = 0; i < classes; ++i)
{
if (sclass < 0 || sclass == i)
{
bool result = predictions[i * 2] > predictions[i * 2 + 1];
bbox_update(a, b, i, result);
}
}
}
private static void test_cifar_multi(string filename, string weightfile)
{
Network net = Parser.parse_network_cfg(filename);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Network.set_batch_network(net, 1);
float avgAcc = 0;
Data.Data test = Data.Data.load_cifar10_data("Data.Data/cifar/cifar-10-batches-bin/test_batch.bin");
int i;
for (i = 0; i < test.X.Rows; ++i)
{
Image im = new Image(32, 32, 3, test.X.Vals[i]);
float[] pred = new float[10];
float[] p = Network.network_predict(net, im.Data);
Blas.Axpy_cpu(10, 1, p, pred);
LoadArgs.flip_image(im);
p = Network.network_predict(net, im.Data);
Blas.Axpy_cpu(10, 1, p, pred);
int index = Utils.max_index(pred, 10);
int sclass = Utils.max_index(test.Y.Vals[i], 10);
if (index == sclass)
{
avgAcc += 1;
}
Console.Write($"%4d: %.2f%%\n", i, 100f * avgAcc / (i + 1));
}
}
private static void train_compare(string cfgfile, string weightfile)
{
float avgLoss = -1;
string basec = Utils.Basecfg(cfgfile);
string backupDirectory = "/home/pjreddie/backup/";
Console.Write($"%s\n", basec);
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Console.Write($"Learning Rate: %g, Momentum: %g, Decay: %g\n", net.LearningRate, net.Momentum, net.Decay);
int imgs = 1024;
string[] paths = Data.Data.GetPaths("Data.Data/compare.train.list");
int n = paths.Length;
Console.Write($"%d\n", n);
var sw = new Stopwatch();
Thread loadThread;
Data.Data train;
Data.Data buffer = new Data.Data();
LoadArgs args = new LoadArgs();
args.W = net.W;
args.H = net.H;
args.Paths = paths;
args.Classes = 20;
args.N = imgs;
args.M = n;
args.D = buffer;
args.Type = DataType.CompareData;
loadThread = Data.Data.load_data_in_thread(args);
int epoch = net.Seen / n;
int i = 0;
while (true)
{
++i;
sw.Reset();
sw.Start();
loadThread.Join();
train = buffer;
loadThread = Data.Data.load_data_in_thread(args);
sw.Stop();
Console.Write($"Loaded: %lf seconds\n", sw.Elapsed.Seconds);
sw.Reset();
sw.Start();
float loss = Network.train_network(net, train);
if (avgLoss == -1)
{
avgLoss = loss;
}
avgLoss = avgLoss * .9f + loss * .1f;
sw.Stop();
Console.Write($"%.3f: %f, %f avg, %lf seconds, %d images\n", (float)net.Seen / n, loss, avgLoss, sw.Elapsed.Seconds, net.Seen);
if (i % 100 == 0)
{
string buff = $"{backupDirectory}/{basec}_{epoch}_minor_{i}.Weights";
Parser.save_weights(net, buff);
}
if (net.Seen / n > epoch)
{
epoch = net.Seen / n;
i = 0;
string buff = $"{backupDirectory}/{basec}_{epoch}.Weights";
Parser.save_weights(net, buff);
if (epoch % 22 == 0)
{
net.LearningRate *= .1f;
}
}
}
loadThread.Join();
}
private static void train_writing(string cfgfile, string weightfile)
{
string backupDirectory = "/home/pjreddie/backup/";
float avgLoss = -1;
string basec = Utils.Basecfg(cfgfile);
Console.Write($"%s\n", basec);
Network net = Parser.parse_network_cfg(cfgfile);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
Console.Write($"Learning Rate: %g, Momentum: %g, Decay: %g\n", net.LearningRate, net.Momentum, net.Decay);
int imgs = net.Batch * net.Subdivisions;
string[] paths = Data.Data.GetPaths("figures.list");
var sw = new Stopwatch();
int n = paths.Length;
Console.Write($"N: %d\n", n);
Image outf = Network.get_network_image(net);
Data.Data buffer = new Data.Data();
LoadArgs args = new LoadArgs();
args.W = net.W;
args.H = net.H;
args.OutW = outf.W;
args.OutH = outf.H;
args.Paths = paths;
args.N = imgs;
args.M = n;
args.D = buffer;
args.Type = DataType.WritingData;
Thread loadThread = Data.Data.load_data_in_thread(args);
int epoch = (net.Seen) / n;
while (Network.get_current_batch(net) < net.MaxBatches || net.MaxBatches == 0)
{
sw.Reset();
sw.Start();
loadThread.Join();
var train = buffer;
loadThread = Data.Data.load_data_in_thread(args);
sw.Stop();
Console.Write($"Loaded %lf seconds\n", sw.Elapsed.Seconds);
sw.Reset();
sw.Start();
float loss = Network.train_network(net, train);
if (avgLoss == -1)
{
avgLoss = loss;
}
avgLoss = avgLoss * .9f + loss * .1f;
Console.Write($"%d, %.3f: %f, %f avg, %f rate, %lf seconds, %d images\n", Network.get_current_batch(net), (float)(net.Seen) / n, loss, avgLoss, Network.get_current_rate(net), sw.Elapsed.Seconds, net.Seen);
if (Network.get_current_batch(net) % 100 == 0)
{
string buff = $"{backupDirectory}/{basec}_batch_{Network.get_current_batch(net)}.Weights";
Parser.save_weights(net, buff);
}
if (net.Seen / n > epoch)
{
epoch = net.Seen / n;
string buff = $"{backupDirectory}/{basec}_{epoch}.Weights";
Parser.save_weights(net, buff);
}
}
}
public Task <IList <IClientSpan> > Load(LoadArgs args)
{
var clientSpanRepository = new ClientSpanRepository(AsyncFile.Instance);
return(clientSpanRepository.Read(args));
}
public Task Delete(LoadArgs args)
{
var clientSpanRepository = new ClientSpanRepository(AsyncFile.Instance);
return(clientSpanRepository.Clear(args));
}
public TexturedPlane DeepCopy(LoadArgs l)
{
return(DeepCopy());
}
public TexturedPlane ShallowCopy(LoadArgs l)
{
return(ShallowCopy());
}
public SessionLocation DeepCopy(LoadArgs l)
{
return(DeepCopy());
}
public SessionLocation ShallowCopy(LoadArgs l)
{
return(ShallowCopy());
}
private static void validate_compare(string filename, string weightfile)
{
int i = 0;
Network net = Parser.parse_network_cfg(filename);
if (string.IsNullOrEmpty(weightfile))
{
Parser.load_weights(net, weightfile);
}
string[] paths = Data.Data.GetPaths("Data.Data/compare.val.list");
int n = paths.Length / 2;
var sw = new Stopwatch();
int correct = 0;
int total = 0;
int splits = 10;
int num = (i + 1) * n / splits - i * n / splits;
Data.Data buffer = new Data.Data();
LoadArgs args = new LoadArgs();
args.W = net.W;
args.H = net.H;
args.Paths = paths;
args.Classes = 20;
args.N = num;
args.M = 0;
args.D = buffer;
args.Type = DataType.CompareData;
Thread loadThread = Data.Data.load_data_in_thread(args);
for (i = 1; i <= splits; ++i)
{
sw.Reset();
sw.Start();
loadThread.Join();
var val = buffer;
num = (i + 1) * n / splits - i * n / splits;
string[] part = new string[paths.Length - (i * n / splits)];
Array.Copy(paths, i * n / splits, part, 0, part.Length);
if (i != splits)
{
args.Paths = part;
loadThread = Data.Data.load_data_in_thread(args);
}
sw.Stop();
Console.Write($"Loaded: %d images ini %lf seconds\n", val.X.Rows, sw.Elapsed.Seconds);
sw.Reset();
sw.Start();
Matrix pred = Network.network_predict_data(net, val);
int j, k;
for (j = 0; j < val.Y.Rows; ++j)
{
for (k = 0; k < 20; ++k)
{
if (val.Y.Vals[j][k * 2] != val.Y.Vals[j][k * 2 + 1])
{
++total;
if ((val.Y.Vals[j][k * 2] < val.Y.Vals[j][k * 2 + 1]) == (pred.Vals[j][k * 2] < pred.Vals[j][k * 2 + 1]))
{
++correct;
}
}
}
}
sw.Stop();
Console.Write($"%d: Acc: %f, %lf seconds, %d images\n", i, (float)correct / total, sw.Elapsed.Seconds, val.X.Rows);
}
}
public Skaia DeepCopy(LoadArgs l)
{
return(DeepCopy());
}
