Tensorflow with Fable-Elmish. A Failed Try

await model.fit(trainData.xs, trainData.labels, {
    batchSize,
    validationSplit,
    epochs: trainEpochs,
    callbacks: {
      onBatchEnd: async (batch, logs) => {
        trainBatchCount++;
        ui.logStatus(
            `Training... (` +
            `${(trainBatchCount / totalNumBatches * 100).toFixed(1)}%` +
            ` complete). To stop training, refresh or close page.`);
        ui.plotLoss(trainBatchCount, logs!.loss, 'train');
        ui.plotAccuracy(trainBatchCount, logs!.acc, 'train');
        if (onIteration && batch % 10 === 0) {
          onIteration('onBatchEnd', batch, logs);
        }
        await tf.nextFrame();
      },
      onEpochEnd: async (epoch, logs) => {
        valAcc = logs!.val_acc;
        ui.plotLoss(trainBatchCount, logs!.val_loss, 'validation');
        ui.plotAccuracy(trainBatchCount, logs!.val_acc, 'validation');
        if (onIteration) {
          onIteration('onEpochEnd', epoch, logs);
        }
        await tf.nextFrame();
      }
    }
  });

let train (tfmodel) (onIteration) (model) dispatch =
        promise {
            LogStatus "Training Model" |> dispatch
            // Now that we've defined our model, we will define our optimizer. The
            // optimizer will be used to optimize our model's weight values during
            // training so that we can decrease our training loss and increase our
            // classification accuracy.
            // The learning rate defines the magnitude by which we update our weights each
            // training step. The higher the value, the faster our loss values converge,
            // but also the more likely we are to overshoot optimal parameters
            // when making an update. A learning rate that is too low will take too long
            // to find optimal (or good enough) weight parameters while a learning rate
            // that is too high may overshoot optimal parameters. Learning rate is one of
            // the most important hyperparameters to set correctly. Finding the right
            // value takes practice and is often best found empirically by trying many
            // values.
            let LearningRate = 0.01
            // We are using rmsprop as our optimizer.
            // An optimizer is an iterative method for minimizing an loss function.
            // It tries to find the minimum of our loss function with respect to the
            // model's weight parameters.
            let optimizer = "rmsprop"
            // We compile our model by specifying an optimizer, a loss function, and a
            // list of metrics that we will use for model evaluation. Here we're using a
            // categorical crossentropy loss, the standard choice for a multi-class
            // classification problem like MNIST digits.
            // The categorical crossentropy loss is differentiable and hence makes
            // model training possible. But it is not amenable to easy interpretation
            // by a human. This is why we include a "metric", namely accuracy, which is
            // simply a measure of how many of the examples are classified correctly.
            // This metric is not differentiable and hence cannot be used as the loss
            // function of the model.
            tfmodel?compile (createObj [ "optimizer" ==> optimizer
                                         "loss" ==> "categoricalCrossentropy"
                                         "metrics" ==> [ "accuracy" ] ])
            // Batch size is another important hyperparameter. It defines the number of
            // examples we group together, or batch, between updates to the model's
            // weights during training. A value that is too low will update weights using
            // too few examples and will not generalize well. Larger batch sizes require
            // more memory resources and aren't guaranteed to perform better.
            let batchSize = 320
            // Leave out the last 15% of the training data for validation, to monitor
            // overfitting during training.
            let validationSplit = 0.15
            // Get number of training epochs from the UI.
            let trainEpochs = model.Epochs
            // We'll keep a buffer of loss and accuracy values over time.
            let trainBatchCount = 0
            let trainData = getTrainData()
            let testData = getTestData (None)
            let totalNumBatches =
                Math.ceil
                    (trainData.xs.shape.[0] * (1. - validationSplit)
                     / (float batchSize)) * (float trainEpochs)
            return ()
        }