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()); }