Javascript Tensorflow.js神经网络中的反向传播

当我尝试在我的代码中实现此功能时，为了进行反向传播，请将（损失）最小化到tf.train.stg（learningRate）。我已经得到了多个错误，比如传递到variableGrads（f）中的f必须是一个函数。我将如何在下面的代码中成功实现上述功能？为什么会出现这种错误呢

神经网络：

    var X = tf.tensor([[1,2,3], [4,5,6], [7,8,9], [10,11,12]])
    var Y = tf.tensor([[0,0,0],[0,0,0], [1,1,1]])
    var m = X.shape[0]
    var a0 = tf.zeros([1,3])
    var y_hat = tf.zeros([1,3])
    var parameters = {
        "Wax": tf.randomUniform([1,3]),
        "Waa": tf.randomUniform([3,3]),
        "ba": tf.zeros([1,3]),
        "Wya": tf.randomUniform([3,3]),
        "by": tf.zeros([1,3])
    }

   

    function RNN_cell_Foward(xt, a_prev, parameters){
        var Wax = parameters["Wax"]
        var Waa = parameters["Waa"]
        var ba = parameters["ba"]

        var a_next = tf.sigmoid(tf.add(tf.add(tf.matMul(xt, Wax), tf.matMul(a_prev , Waa)),ba))

        return a_next
    }
    function RNN_FowardProp(X, a0, parameters){
        var T_x  = X.shape[0]
        var a_next = a0
        var i = 1
        var Wya = parameters["Wya"]
        var by = parameters["by"]
        var l = 1
        
        
        for(; i <= T_x; i++){
            var X_i = X.slice([i-1,0],[1,-1])
            for(; l <= X.shape[1]; l++){
                var xt = X_i.slice([0,l-1],[1,1])
                var a_next = RNN_cell_Foward(xt, a_next, parameters)
            }
            var y_pred = tf.sigmoid((tf.add(tf.matMul(a_next, Wya), by)))
            l = 1
            
            if (i == 1){
                var y_pred1 = y_pred
            } else if (i == 2) {
                var y_pred2 = y_pred
            } else if (i == 3) {
                var y_pred3 = y_pred
            }
            
            
        }
        var y_predx = tf.concat([y_pred1, y_pred2, y_pred3])
        return y_predx
    }
        const learningRate = 0.01;
        var optimizer = tf.train.sgd(learningRate);
        var model = RNN_FowardProp(X, a0, parameters)
        var loss = tf.losses.meanSquaredError(Y, model)
    
    
    
        for (let f = 0; f < 10; f++) {
            optimizer.minimize(loss)
        }

var X=tf.张量（[1,2,3]，[4,5,6]，[7,8,9]，[10,11,12]）
变量Y=tf.张量（[[0,0,0]，[0,0,0]，[1,1,1]]
var m=X.shape[0]
var a0=tf.零（[1,3]）
变量y_hat=tf.zeros（[1,3]）
变量参数={
“蜡”：tf.随机均匀（[1,3]），
“Waa”：tf.随机均匀（[3,3]），
“ba”：tf.零（[1,3]），
“Wya”：tf.随机均匀（[3,3]），
“by”：tf.zeros（[1,3]）
}
函数RNN\u cell\u Foward（xt，a\u prev，参数）{
变量蜡=参数[“蜡”]
var Waa=参数[“Waa”]
var ba=参数[“ba”]
var a_next=tf.sigmoid（tf.add（tf.matMul（xt，Wax），tf.matMul（a_prev，Waa）），ba））
下一步返回a_
}
函数RNN_FowardProp（X，a0，参数）{
var T_x=x.shape[0]
var a_next=a0
变量i=1
var Wya=参数[“Wya”]
var by=参数[“by”]
var l=1
对于（；i而言，错误说明了一切：

传入的variableGrads（f）必须是函数

optimizer.minimize
期望函数作为参数，而不是张量。由于代码试图最小化MeansquaredRor，
minimize
的参数可以是计算预测值和期望值之间的MeansquaredRor的函数

const loss = (pred, label) => pred.sub(label).square().mean();

for (let f = 0; f < 10; f++) {
            optimizer.minimize(() => tf.losses.meanSquaredError(Y, model))
}

这意味着什么？当使用优化器时，它希望作为参数传递的函数包含变量，这些变量的值将更新为函数输出的
minimize

以下是将要进行的更改：

var Y = tf.tensor([[0,0,0],[0,0,0], [1,1,1]]).variable() // a variable instead

// var loss = tf.losses.meanSquaredError(Y, model)
// computed below in the minimize function

const learningRate = 0.01;
var optimizer = tf.train.sgd(learningRate);
var model = RNN_FowardProp(X, a0, parameters);

const loss = (pred, label) => pred.sub(label).square().mean();
for (let f = 0; f < 10; f++) {
    optimizer.minimize(() => tf.losses.meanSquaredError(Y, model))
}

var Y=tf.tensor（[[0,0,0]，[0,0,0]，[1,1,1]]）。variable（）//改为变量
//var损失=tf损失均方误差（Y，模型）
//在下面的最小化函数中计算
常数学习率=0.01；
var优化器=tf.train.sgd（学习率）；
var模型=RNN_FowardProp（X，a0，参数）；
常量损失=（pred，label）=>pred.sub（label.square（）.mean（）；
对于（设f=0；f<10；f++）{
优化器。最小化（（）=>tf.损失。平均平方误差（Y，模型））
}

var Y = tf.tensor([[0,0,0],[0,0,0], [1,1,1]]).variable() // a variable instead

// var loss = tf.losses.meanSquaredError(Y, model)
// computed below in the minimize function

const learningRate = 0.01;
var optimizer = tf.train.sgd(learningRate);
var model = RNN_FowardProp(X, a0, parameters);

const loss = (pred, label) => pred.sub(label).square().mean();
for (let f = 0; f < 10; f++) {
    optimizer.minimize(() => tf.losses.meanSquaredError(Y, model))
}