Пример #1
0
        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));
        }
Пример #2
0
        private static void eval_cifar_csv()
        {
            Data.Data test = Data.Data.load_cifar10_data("Data.Data/cifar/cifar-10-batches-bin/test_batch.bin");

            Matrix pred = new Matrix("results/combined.csv");

            Console.Error.Write($"%d %d\n", pred.Rows, pred.Cols);

            Console.Error.Write($"Accuracy: %f\n", Matrix.matrix_topk_accuracy(test.Y, pred, 1));
        }
Пример #3
0
        private static void train_cifar(string cfgfile, string weightfile)
        {
            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);

            string backupDirectory = "/home/pjreddie/backup/";
            int    n = 50000;

            Data.Data.get_labels("Data.Data/cifar/labels.txt");
            int epoch = (net.Seen) / n;

            Data.Data train = Data.Data.load_all_cifar10();
            var       sw    = new Stopwatch();

            while (Network.get_current_batch(net) < net.MaxBatches || net.MaxBatches == 0)
            {
                sw.Reset();
                sw.Start();

                float loss = Network.train_network_sgd(net, train, 1);
                if (avgLoss == -1)
                {
                    avgLoss = loss;
                }
                avgLoss = avgLoss * .95f + loss * .05f;
                sw.Stop();
                Console.Write(
                    $"{Network.get_current_batch(net)}, {net.Seen / n:.3}: {loss}, {avgLoss} avg, {Network.get_current_rate(net)} rate, {sw.Elapsed.Seconds} seconds, {net.Seen} images\n");
                if (net.Seen / n > epoch)
                {
                    epoch = net.Seen / n;

                    string buff = $"{backupDirectory}/{basec}_{epoch}.Weights";
                    Parser.save_weights(net, buff);
                }
                if (Network.get_current_batch(net) % 100 == 0)
                {
                    string buff = $"{backupDirectory}/{basec}.backup";
                    Parser.save_weights(net, buff);
                }
            }

            string buff2 = $"{backupDirectory}/{basec}.Weights";

            Parser.save_weights(net, buff2);
        }
Пример #4
0
        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);
            }
        }
Пример #5
0
        private static void test_cifar(string filename, string weightfile)
        {
            Network net = Parser.parse_network_cfg(filename);

            if (string.IsNullOrEmpty(weightfile))
            {
                Parser.load_weights(net, weightfile);
            }


            var   sw     = new Stopwatch();
            float avgAcc = 0;

            Data.Data test = Data.Data.load_cifar10_data("Data.Data/cifar/cifar-10-batches-bin/test_batch.bin");

            sw.Start();

            float[] acc = Network.network_accuracies(net, test, 2);
            avgAcc += acc[0];
            sw.Stop();
            Console.Write($"top1: %f, %lf seconds, %d images\n", avgAcc, sw.Elapsed.Seconds, test.X.Rows);
        }
Пример #6
0
        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));
            }
        }
Пример #7
0
        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);
                }
            }
        }
Пример #8
0
        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);
            }
        }
Пример #9
0
        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();
        }
Пример #10
0
        private static void validate_classifier_crop(string datacfg, string filename, string weightfile)
        {
            int     i   = 0;
            Network net = Parser.parse_network_cfg(filename);

            if (string.IsNullOrEmpty(weightfile))
            {
                Parser.load_weights(net, weightfile);
            }


            var options = OptionList.read_data_cfg(datacfg);

            string labelList = OptionList.option_find_str(options, "labels", "Data.Data/labels.list");
            string validList = OptionList.option_find_str(options, "valid", "Data.Data/train.list");
            int    classes   = OptionList.option_find_int(options, "classes", 2);
            int    topk      = OptionList.option_find_int(options, "top", 1);

            string[] labels = Data.Data.get_labels(labelList);

            string[] paths = Data.Data.GetPaths(validList);
            int      m     = paths.Length;

            var   sw      = new Stopwatch();
            float avgAcc  = 0;
            float avgTopk = 0;
            int   splits  = m / 1000;
            int   num     = (i + 1) * m / splits - i * m / splits;

            Data.Data buffer = new Data.Data();

            LoadArgs args = new LoadArgs();

            args.W = net.W;
            args.H = net.H;

            args.Paths   = paths;
            args.Classes = classes;
            args.N       = num;
            args.M       = 0;
            args.Labels  = labels;
            args.D       = buffer;
            args.Type    = DataType.OldClassificationData;

            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) * m / splits - i * m / splits;
                string[] part = new string[paths.Length - (i * m / splits)];
                Array.Copy(paths, i * m / 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();
                float[] acc = Network.network_accuracies(net, val, topk);
                avgAcc  += acc[0];
                avgTopk += acc[1];
                sw.Stop();
                Console.Write($"%d: top 1: %f, top %d: %f, %lf seconds, %d images\n", i, avgAcc / i, topk, avgTopk / i, sw.Elapsed.Seconds, val.X.Rows);
            }
        }
Пример #11
0
        private static void test_classifier(string datacfg, string cfgfile, string weightfile, int targetLayer)
        {
            int     curr = 0;
            Network net  = Parser.parse_network_cfg(cfgfile);

            if (string.IsNullOrEmpty(weightfile))
            {
                Parser.load_weights(net, weightfile);
            }


            var options = OptionList.read_data_cfg(datacfg);

            string testList = OptionList.option_find_str(options, "test", "Data.Data/test.list");
            int    classes  = OptionList.option_find_int(options, "classes", 2);

            string[] paths = Data.Data.GetPaths(testList);
            int      m     = paths.Length;

            var sw = new Stopwatch();

            Data.Data buffer = new Data.Data();

            LoadArgs args = new LoadArgs();

            args.W       = net.W;
            args.H       = net.H;
            args.Paths   = paths;
            args.Classes = classes;
            args.N       = net.Batch;
            args.M       = 0;
            args.Labels  = new string[0];
            args.D       = buffer;
            args.Type    = DataType.OldClassificationData;

            Thread loadThread = Data.Data.load_data_in_thread(args);

            for (curr = net.Batch; curr < m; curr += net.Batch)
            {
                sw.Reset();
                sw.Start();

                loadThread.Join();
                var val = buffer;

                if (curr < m)
                {
                    args.Paths = new string[paths.Length - curr];
                    Array.Copy(paths, curr, args.Paths, 0, args.Paths.Length);
                    if (curr + net.Batch > m)
                    {
                        args.N = m - curr;
                    }
                    loadThread = Data.Data.load_data_in_thread(args);
                }
                sw.Stop();
                Console.Error.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 i, j;

                for (i = 0; i < pred.Rows; ++i)
                {
                    Console.Write($"%s", paths[curr - net.Batch + i]);
                    for (j = 0; j < pred.Cols; ++j)
                    {
                        Console.Write($"\t%g", pred.Vals[i][j]);
                    }
                    Console.Write($"\n");
                }

                sw.Stop();
                Console.Error.Write($"%lf seconds, %d images, %d total\n", sw.Elapsed.Seconds, val.X.Rows, curr);
            }
        }
Пример #12
0
        private static void train_classifier(string datacfg, string cfgfile, string weightfile, int[] gpus, int ngpus, bool clear)
        {
            int i;

            float  avgLoss = -1;
            string basec   = Utils.Basecfg(cfgfile);

            Console.Write($"%s\n", basec);
            Console.Write($"%d\n", ngpus);
            Network[] nets = new Network[ngpus];


            int seed = Utils.Rand.Next();

            for (i = 0; i < ngpus; ++i)
            {
                nets[i] = Parser.parse_network_cfg(cfgfile);
                if (string.IsNullOrEmpty(weightfile))
                {
                    Parser.load_weights(nets[i], weightfile);
                }
                if (clear)
                {
                    nets[i].Seen = 0;
                }
                nets[i].LearningRate *= ngpus;
            }

            Network net = nets[0];

            int imgs = net.Batch * net.Subdivisions * ngpus;

            Console.Write($"Learning Rate: %g, Momentum: %g, Decay: %g\n", net.LearningRate, net.Momentum, net.Decay);
            var options = OptionList.read_data_cfg(datacfg);

            string backupDirectory = OptionList.option_find_str(options, "backup", "/backup/");
            string labelList       = OptionList.option_find_str(options, "labels", "Data.Data/labels.list");
            string trainList       = OptionList.option_find_str(options, "train", "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(trainList);
            Console.Write($"%d\n", paths.Length);
            int n  = paths.Length;
            var sw = new Stopwatch();

            LoadArgs args = new LoadArgs();

            args.W         = net.W;
            args.H         = net.H;
            args.Threads   = 32;
            args.Hierarchy = net.Hierarchy;

            args.Min        = net.MinCrop;
            args.Max        = net.MaxCrop;
            args.Angle      = net.Angle;
            args.Aspect     = net.Aspect;
            args.Exposure   = net.Exposure;
            args.Saturation = net.Saturation;
            args.Hue        = net.Hue;
            args.Size       = net.W;

            args.Paths   = paths;
            args.Classes = classes;
            args.N       = imgs;
            args.M       = n;
            args.Labels  = labels;
            args.Type    = DataType.ClassificationData;

            Data.Data train;
            Data.Data buffer = new Data.Data();
            Thread    loadThread;

            args.D     = buffer;
            loadThread = Data.Data.load_data(args);

            int epoch = (net.Seen) / n;

            while (Network.get_current_batch(net) < net.MaxBatches || net.MaxBatches == 0)
            {
                sw.Reset();
                sw.Start();

                loadThread.Join();
                train      = buffer;
                loadThread = Data.Data.load_data(args);

                sw.Stop();
                Console.Write($"Loaded: %lf seconds\n", sw.Elapsed.Seconds);
                sw.Reset();
                sw.Start();

                float loss = 0;
                if (ngpus == 1)
                {
                    loss = Network.train_network(net, train);
                }
                else
                {
                    loss = Network.train_networks(nets, ngpus, train, 4);
                }
                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 (net.Seen / n > epoch)
                {
                    epoch = net.Seen / n;

                    string buff = $"{backupDirectory}/{basec}_{epoch}.Weights";
                    Parser.save_weights(net, buff);
                }
                if (Network.get_current_batch(net) % 100 == 0)
                {
                    string buff = $"{backupDirectory}/{basec}.backup";
                    Parser.save_weights(net, buff);
                }
            }

            string buff2 = $"{backupDirectory}/{basec}.Weights";

            Parser.save_weights(net, buff2);
        }
Пример #13
0
        private static void train_yolo(string cfgfile, string weightfile)
        {
            string trainImages     = "/Data.Data/voc/train.txt";
            string backupDirectory = "/home/pjreddie/backup/";

            string basec = Utils.Basecfg(cfgfile);

            Console.Write($"%s\n", basec);
            float   avgLoss = -1;
            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;
            int i    = net.Seen / imgs;

            Data.Data buffer = new Data.Data();

            Layer l = net.Layers[net.N - 1];

            int   side    = l.Side;
            int   classes = l.Classes;
            float jitter  = l.Jitter;

            string[] paths = Data.Data.GetPaths(trainImages);

            LoadArgs args = new LoadArgs();

            args.W        = net.W;
            args.H        = net.H;
            args.Paths    = paths;
            args.N        = imgs;
            args.M        = paths.Length;
            args.Classes  = classes;
            args.Jitter   = jitter;
            args.NumBoxes = side;
            args.D        = buffer;
            args.Type     = DataType.RegionData;

            args.Angle      = net.Angle;
            args.Exposure   = net.Exposure;
            args.Saturation = net.Saturation;
            args.Hue        = net.Hue;

            Thread loadThread = Data.Data.load_data_in_thread(args);
            var    sw         = new Stopwatch();

            while (Network.get_current_batch(net) < net.MaxBatches)
            {
                i += 1;
                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 < 0)
                {
                    avgLoss = loss;
                }
                avgLoss = avgLoss * .9f + loss * .1f;

                sw.Stop();
                Console.Write($"%d: %f, %f avg, %f rate, %lf seconds, %d images\n", i, loss, avgLoss, Network.get_current_rate(net), sw.Elapsed.Seconds, i * imgs);
                if (i % 1000 == 0 || (i < 1000 && i % 100 == 0))
                {
                    string buff = $"{backupDirectory}/{basec}_{i}.Weights";
                    Parser.save_weights(net, buff);
                }
            }

            string buff2 = $"{backupDirectory}/{basec}_final.Weights";

            Parser.save_weights(net, buff2);
        }
Пример #14
0
        private static void train_super(string cfgfile, string weightfile)
        {
            string trainImages     = "/Data.Data/imagenet/imagenet1k.train.list";
            string backupDirectory = "/home/pjreddie/backup/";

            string basec = Utils.Basecfg(cfgfile);

            Console.Write($"%s\n", basec);
            float   avgLoss = -1;
            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;
            int i    = net.Seen / imgs;

            Data.Data buffer = new Data.Data();

            string[] paths = Data.Data.GetPaths(trainImages);

            LoadArgs args = new LoadArgs();

            args.W     = net.W;
            args.H     = net.H;
            args.Scale = 4;
            args.Paths = paths;
            args.N     = imgs;
            args.M     = paths.Length;
            args.D     = buffer;
            args.Type  = DataType.SuperData;

            Thread loadThread = Data.Data.load_data_in_thread(args);
            var    sw         = new Stopwatch();

            //while(i*imgs < N*120){
            while (Network.get_current_batch(net) < net.MaxBatches)
            {
                i += 1;
                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 < 0)
                {
                    avgLoss = loss;
                }
                avgLoss = avgLoss * .9f + loss * .1f;

                sw.Stop();
                Console.Write($"%d: %f, %f avg, %f rate, %lf seconds, %d images\n", i, loss, avgLoss, Network.get_current_rate(net), sw.Elapsed.Seconds, i * imgs);
                if (i % 1000 == 0)
                {
                    string buffa = $"{backupDirectory}/{basec}_{i}.Weights";
                    Parser.save_weights(net, buffa);
                }
                if (i % 100 == 0)
                {
                    string buffb = $"{backupDirectory}/{basec}.backup";
                    Parser.save_weights(net, buffb);
                }
            }
            string buff = $"{backupDirectory}/{basec}_final.Weights";

            Parser.save_weights(net, buff);
        }
Пример #15
0
        private static void train_tag(string cfgfile, string weightfile, bool clear)
        {
            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);
            }
            if (clear)
            {
                net.Seen = 0;
            }
            Console.Write($"Learning Rate: %g, Momentum: %g, Decay: %g\n", net.LearningRate, net.Momentum, net.Decay);
            int imgs = 1024;

            string[] paths = Data.Data.GetPaths("/home/pjreddie/tag/train.list");
            Console.Write($"%d\n", paths.Length);
            int    n  = paths.Length;
            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.Min  = net.W;
            args.Max  = net.MaxCrop;
            args.Size = net.W;

            args.Paths   = paths;
            args.Classes = net.Outputs;
            args.N       = imgs;
            args.M       = n;
            args.D       = buffer;
            args.Type    = DataType.TagData;

            args.Angle      = net.Angle;
            args.Exposure   = net.Exposure;
            args.Saturation = net.Saturation;
            args.Hue        = net.Hue;

            Console.Error.Write($"%d classes\n", net.Outputs);

            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();
                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 (net.Seen / n > epoch)
                {
                    epoch = net.Seen / n;

                    string buff = $"{backupDirectory}/{basec}_{epoch}.Weights";
                    Parser.save_weights(net, buff);
                }
                if (Network.get_current_batch(net) % 100 == 0)
                {
                    string buff = $"{backupDirectory}/{basec}.backup";
                    Parser.save_weights(net, buff);
                }
            }

            string buff2 = $"{backupDirectory}/{basec}.Weights";

            Parser.save_weights(net, buff2);

            loadThread.Join();
        }
Пример #16
0
        private static void train_detector(string datacfg, string cfgfile, string weightfile, bool clear)
        {
            var    options         = OptionList.read_data_cfg(datacfg);
            string trainImages     = OptionList.option_find_str(options, "train", "Data.Data/train.list");
            string backupDirectory = OptionList.option_find_str(options, "backup", "/backup/");


            string basec = Utils.Basecfg(cfgfile);

            Console.Write($"%s\n", basec);
            float avgLoss = -1;

            Network[] nets = new Network[1];


            int seed = Utils.Rand.Next();
            int i;

            for (i = 0; i < 1; ++i)
            {
                nets[i] = Parser.parse_network_cfg(cfgfile);
                if (string.IsNullOrEmpty(weightfile))
                {
                    Parser.load_weights(nets[i], weightfile);
                }
                if (clear)
                {
                    nets[i].Seen = 0;
                }
                nets[i].LearningRate *= 1;
            }

            Network net = nets[0];

            int imgs = net.Batch * net.Subdivisions * 1;

            Console.Write($"Learning Rate: %g, Momentum: %g, Decay: %g\n", net.LearningRate, net.Momentum, net.Decay);
            Data.Data buffer = new Data.Data();

            Layer l = net.Layers[net.N - 1];

            int   classes = l.Classes;
            float jitter  = l.Jitter;

            string[] paths = Data.Data.GetPaths(trainImages);

            LoadArgs args = new LoadArgs();

            args.W        = net.W;
            args.H        = net.H;
            args.Paths    = paths;
            args.N        = imgs;
            args.M        = paths.Length;
            args.Classes  = classes;
            args.Jitter   = jitter;
            args.NumBoxes = l.MaxBoxes;
            args.D        = buffer;
            args.Type     = DataType.DetectionData;
            args.Threads  = 8;

            args.Angle      = net.Angle;
            args.Exposure   = net.Exposure;
            args.Saturation = net.Saturation;
            args.Hue        = net.Hue;

            Thread loadThread = Data.Data.load_data(args);
            var    sw         = new Stopwatch();
            int    count      = 0;

            while (Network.get_current_batch(net) < net.MaxBatches)
            {
                Data.Data train;
                if (l.Random && count++ % 10 == 0)
                {
                    Console.Write($"Resizing\n");
                    int dim = (Utils.Rand.Next() % 10 + 10) * 32;
                    if (Network.get_current_batch(net) + 100 > net.MaxBatches)
                    {
                        dim = 544;
                    }
                    Console.Write($"%d\n", dim);
                    args.W = dim;
                    args.H = dim;

                    loadThread.Join();
                    loadThread = Data.Data.load_data(args);

                    for (i = 0; i < 1; ++i)
                    {
                        Network.resize_network(nets[i], dim, dim);
                    }
                    net = nets[0];
                }
                sw.Start();
                loadThread.Join();
                train      = buffer;
                loadThread = Data.Data.load_data(args);
                sw.Stop();
                Console.Write($"Loaded: %lf seconds\n", sw.Elapsed.Seconds);

                sw.Reset();
                sw.Start();
                float loss;
                loss = Network.train_network(net, train);
                if (avgLoss < 0)
                {
                    avgLoss = loss;
                }
                avgLoss = avgLoss * .9f + loss * .1f;

                i = Network.get_current_batch(net);
                sw.Stop();
                Console.Write($"%d: %f, %f avg, %f rate, %lf seconds, %d images\n", Network.get_current_batch(net), loss, avgLoss, Network.get_current_rate(net), sw.Elapsed.Seconds, i * imgs);
                if (i % 1000 == 0 || (i < 1000 && i % 100 == 0))
                {
                    string buffa = $"{backupDirectory}/{basec}_{i}.Weights";
                    Parser.save_weights(net, buffa);
                }
            }

            string buff = $"{backupDirectory}/{basec}_final.Weights";

            Parser.save_weights(net, buff);
        }