0

我是机器学习的新手，但决定为神经网络制作自己的 js 库，一切都很完美，直到我尝试训练我的 NN。在我的迷你图书馆中，我创建了一些功能......

1）创建我的神经元对象的函数：

this.Node = function (conns) {
        var output = {};
        output.b = hyth.Random({type: "TanH"});
        output.w = [];

        for (var a = 0; a < conns; a++){
            output.w[a] = hyth.Random({type: "TanH"});
        }

        output.Value = function (i) {
            if (i.length == conns) {
                var sum = 0;
                for (var a = 0; a < conns; a++){
                    sum += i[a] * output.w[a];
                }
                sum += output.b;
                return myMath.Activate(sum, {type: "Sigmoid"});
            }
        }

        return output;
    }

这个函数有一个参数，它是来自神经元的所需权重的数量，它返回一个具有两个属性的对象——“b”浮点数（偏差），“w”包含浮点数的一维数组，以及一个方法——它计算神经元对象的激活。

2) 创建我的神经网络的函数

this.Network = function () {
        var p = arguments;
        var arr = [];
        for (var a = 0; a < p.length-1; a++){
            arr[a] = [];
            for (var b = 0; b < p[a+1]; b++){
                arr[a][b] = this.Node(p[a]);
            }
        }

        return arr;
    }

此函数返回一个以神经元对象为最终值的 2D 数组，使用参数数组作为每层的层数和节点数的设置。

3) 一个前馈神经网络的函数

this.Forward = function (network, input) {
        if (network[0][0].w.length == input.length) {
            var activations = [];

            for (var a = 0; a < network.length; a++){
                activations[a] = [];
                for (var c = 0; c < network[a].length; c++){
                    if (a == 0){
                        activations[0][c] = network[0][c].Value(input);
                        continue;
                    }
                    activations[a][c] = network[a][c].Value(activations[a-1]);
                }
            }

            return activations;
        }
    }

此函数返回 2D 数组，其中每个神经元都有一个激活浮点数，因为它是最终值。它使用 2 个参数 - 第二个函数的输出，输入数组。

4) 以及反向传播的最终函数

this.Backward = function (network, input, target) {
        if (network[0][0].w.length == input.length && network[network.length-1].length == target.length) {
            var activations = this.Forward(network, input, true);
            var predictions = activations[activations.length-1];

            var errors = [];

            for (var v = 0; v < network.length; v++) {
                errors[v] = [];
            }

            for (var a = network.length-1; a > -1; a--){
                for (var x = 0; x < network[a].length; x++) {
                    var deract = hyth.Deractivate(activations[a][x]);
                    if (a == network.length-1) {
                        errors[a][x] = (predictions[x] - target[x]) * deract;
                    } else {
                        errors[a][x] = 0;
                        for (var y = 0; y < network[a+1].length; y++) {
                            errors[a][x] += network[a+1][y].w[x] * errors[a+1][y];
                        }
                        errors[a][x] *= deract;
                    }
                }
            }

            return errors;
        }
    }

此函数返回 2D 数组，其中每个神经元的 rror 浮点数作为其最终值。参数是 3 - nnet 、输入和想要的输出。

所以我可以制作一个神经网络，前馈和反向传播，接收激活和错误，但我总是无法用我的错误和激活训练我的网络以完美工作，上次它为每种类型的输入输出相同的结果。我想从零开始理解训练算法，所以我需要有人的帮助。

PS-我不想有人说我需要使用著名的图书馆，我想自己理解并制作。

4

0 回答 0