How to take the data? | 易学教程

问题

I am learning to use neural networks, and have encountered a problem. I can not figure out how to convert data for a neural network.

As I understand it, I need to normalize the data, after normalization and learning, the answer is always averaged.

https://jsfiddle.net/eoy7krzj/

<html>
<head>
    <script src="https://cdn.rawgit.com/BrainJS/brain.js/5797b875/browser.js"></script>

</head>
<body>

<div>
    <button onclick="train()">train</button><button onclick="Generate.next(); Generate.draw();">generate</button><button onclick="calculate()">calculate</button>
</div>

<canvas id="generate" style="border: 1px solid #000"></canvas>

</body>

<script type="text/javascript">
    var trainData = [];

    function randomInteger(min, max) {
        var rand = min - 0.5 + Math.random() * (max - min + 1)
        //rand = Math.round(rand);
        return rand;
    }

    function getRandomColor() {
        var letters = '0123456789ABCDEF';

        var color = '#';

        for (var i = 0; i < 6; i++) {
            color += letters[Math.floor(Math.random() * 16)];
        }

        return color;
    }


    var Generate   = new function(){
        var canvas = document.getElementById('generate');
        var ctx    = canvas.getContext('2d');
        var elem   = {
            input: [],
            output: []
        }

        var size = {
            width: 240,
            height: 140
        }

        canvas.width  = 500;
        canvas.height = 250;

        this.next = function(){
            this.build();

            trainData.push({
                input: elem.input,
                output: elem.output
            });
        }

        this.clear = function(){
            ctx.clearRect(0, 0, canvas.width, canvas.height);
        }

        this.draw = function(){
            this.clear();

            this.item(elem.input, function(item){
                ctx.strokeStyle = "green";

                ctx.strokeRect(item[0], item[1], item[2], item[3]);
            })

            this.item(elem.output, function(item){
                ctx.strokeStyle = "blue";

                ctx.strokeRect(item[0], item[1], item[2], item[3]);
            })


        }

        this.item = function(where, call){
            for (var i = 0; i < where.length; i+=4) {
                var input = [
                    where[i],
                    where[i+1],
                    where[i+2],
                    where[i+3],
                ];

                this.denormalize(input);

                call(input)
            }
        }

        this.normalize = function(input){
            input[0] = input[0] / 500;
            input[1] = input[1] / 250;
            input[2] = input[2] / 500;
            input[3] = input[3] / 250;
        }

        this.denormalize = function(input){
            input[0] = input[0] * 500;
            input[1] = input[1] * 250;
            input[2] = input[2] * 500;
            input[3] = input[3] * 250;
        }

        this.empty = function(add){
            var data = [];

            for (var i = 0; i < add; i++) {
                data = data.concat([0,0,0,0]);
            }

            return data;
        }

        this.build = function(){
            var output  = [];
            var input   = [];

            size.width  = randomInteger(100,500);
            size.height = randomInteger(50,250);

            var lines       = 1;//Math.round(size.height / 100);
            var line_size   = 0;
            var line_offset = 0;

            for(var i = 0; i < lines; i++){
                line_size = randomInteger(30,Math.round(size.height / lines));

                var columns        = Math.round(randomInteger(1,3));
                var columns_width  = 0;
                var columns_offset = 0;

                for(var c = 0; c < columns; c++){
                    columns_width = randomInteger(30,Math.round(size.width / columns));

                    var item = [
                        columns_offset + 10,
                        line_offset + 10,
                        columns_width - 20,
                        line_size - 20
                    ];

                    this.normalize(item);

                    input = input.concat(item);

                    columns_offset += columns_width;
                }

                var box = [
                    0,
                    line_offset,
                    columns_offset,
                    line_size
                ]

                this.normalize(box);

                output = output.concat(box);

                line_offset += line_size + 10;
            }

            elem.input  = input.concat(this.empty(5 - Math.round(input.length / 4)));
            elem.output = output.concat(this.empty(2 - Math.round(output.length / 4)));
        }

        this.get = function(){
            return elem.input;
        }


        this.calculate = function(result, stat){
            console.log('brain:',result);

            this.item(result, function(item){
                ctx.strokeStyle = "red";

                ctx.strokeRect(item[0], item[1], item[2], item[3]);
            })
        }

        this.train = function(){
            for(var i = 0; i < 40; i++){
                this.next();
            }
        }
    }

    Generate.train();

    Generate.log = true;

    var net,stat;


    function train(){
        net  = new brain.NeuralNetwork({ hiddenLayers: [8,4]});
        stat = net.train(trainData,{log: true, iterations: 250,learningRate: 0.01,errorThresh:0.05});

        console.log('stat:',stat)
    }

    function calculate(){
        Generate.calculate(net.run(Generate.get()))
    }


</script>
</html>

My goal is to train the network to find the elements and show their sizes.

Procedure: Click to train Click generate Click to calculate

As a result, the network shows average results and red indicates that the network has found. Maybe not so I transfer the data, can on another it is necessary?

来源：https://stackoverflow.com/questions/55781990/how-to-take-the-data

标签

javascript

neural-network

brain.js