deeplearnjs 介绍 <一>

闲来再做回搬运工，感觉和机器翻译比起来并没啥优势。。。

deeplearn.js 是一个用于机器智能的开源 WebGL 加速的 JavaScript 库。deeplearn.js 为您的指尖带来高性能机器学习构建模块，允许您在浏览器中训练神经网络或在推理模式下运行预训练模型。

让我们来看看 deeplearn.js 中的一些核心概念。

Tensors

在 deeplearn.js 中数据的核心单元便是 tensor，一个 Tensor 由一组任意维数的数值型数组构成。
Tensors 由 shape 属性定义其形状。该库为低秩的张量（Tensors）提供了 sugar 般的子类：Scalar, Tensor1D, Tensor2D, Tensor3D 和 Tensor4D，以及一些用于构建它们的辅助函数。

例如使用一个 2x3 维矩阵：

let shape = [2, 3]; // 2 rows, 3 columns
let a = dl.tensor2d([1.0, 2.0, 3.0, 10.0, 20.0, 30.0], shape);
// deeplearn.js can also infer the shape
let b = dl.tensor2d([[0.0, 2.0], [4.0, 6.0]]);  // 2 rows, 2 columns

译者注：可见 shape 重新规定了前面数组的形状。

Tensor 既可以用一个 WebGLTexture 将数据存到 GPU，或者以 JavaScript TypedArray 的形式存到 CPU 上。大多时候，用户都无需考虑存储问题，因为它是一个实现细节。

有个地方你得好好想想其差异的，就是当从一个 Tensor 取出数据时，例如在调试时：

let a = dl.tensor2d([[0.0, 2.0], [4.0, 6.0]]);
a = a.square();

// Async call to get the data from the tensor
a.data().then(data => console.log('The data TypedArray', data));

// Alternatively we can also call this synchronously
let data = a.dataSync();
console.log('The data TypedArray', data);

在上例中，我们首先创建了一个 tensor，然后在其上调用了一个数学操作。这会将该 tensor 自动上传到 GPU。当我们想在 JavaScript 上下文使用它时（如打印出来），我们调用 data() 或 dataSync() 将其下载到 CPU 内存中。请注意这是一个相对有代价的操作，所以你可能倾向于异步调用的版本。

译者注：需要搞明白的是——数据从哪导到哪，怎样的过程有什么开销，以及哪些数据该在 GPU 运算更好

Operations (Ops)

Tensors 允许我们存储数据，同时 Ops 允许我们操纵数据。deeplearn.js 带有大量的适合于线性代数和机器学习的数学运算。它们有像square()的一元运算，像add()的二元运算以及mul()这样的对某个 tensors 进行变换并返回一个新的 tensors 结果的运算。

let a = dl.tensor2d([[1.0, 2.0], [3.0, 4.0]]);  // tensor 
let b = dl.tensor2d([[0.0, 2.0], [4.0, 6.0]]);  // tensor 

// The library has a chainable API allowing you to call operations
// directly as methods on Tensors.
let average = a.sub(b).square().mean();

// All operations are also exposed as functions in the main namespace
// so we could also do.
// 译者注：这些方法不仅每个 tensor 实例都有，而且在 dl 这个命名空间上能直接访问到
let avg = dl.mean(dl.square(dl.sub(a, b)));

Tidy Operations

因为 deeplearn.js 使用了GPU加速数学运算，因此有必要管理GPU内存。在常规的 JavaScript 中，这部分工作由作用域（Scopes）处理，而在这里，我们提供了一个便捷的函数对 tensors
执行操作时所产生的中间内存进行清理。

我们把这个函数称作dl.tidy.

let a = dl.tensor2d([1.0, 2.0, 3.0, 4.0]);

// dl.tidy takes a function to tidy up after
let average = dl.tidy(() => {
  // dl.tidy will clean up all the GPU memory used by tensors inside
  // this function, other than the tensor that is returned.
  //
  // Even in a short sequence of operations like the one below, a number
  // of intermediate tensors get created. So it is a good practice to
  // put your math ops in a tidy!
  return a.sub(b).square().mean();
});

运用dl.tidy()有助于防止应用程序的内存泄漏，并且能更谨慎地控制何时内存回收。

手动方式清理 tensor 内存是dispose方法。

let a = dl.tensor2d([[0.0, 2.0], [4.0, 6.0]]);
a = a.square();
a.dispose(); // Clean up GPU buffer

相比，使用dl.tidy函数更方便些。

Training

许多机器学习的核心问题是实质上是训练机器完成一些任务的问题。在 deeplearn.js 中，这一过程被封装在Optimizers（优化器）中。优化器是逐步调整模型变量的策略，目的是减少模型预测的错误（或者按机器学习的说法是减少损失）。

我们在教程中涵盖了训练和优化器，这里是 deeplearn.js 如何进行训练的一个大概轮廓：

import * as dl from 'deeplearn';

// 初始化模型变量
const weights = dl.variable(dl.randomNormal([10, 64]));
const biases = dl.variable(dl.zeros([64]));

// 设置学习率和创建优化器.
const LEARNING_RATE = .1;
const optimizer = dl.train.sgd(LEARNING_RATE)

/*
 * 进行推断并返回预测结果
 */
function inference(input) { }

/**
 * 通过比较预测值和真实值，计算模型损失
 *
 * 返回一个标量损失值 (如，单数值的张量)
 */
function loss(predictions, labels) { }

/**
 * 模型的单步训练
 */
function trainStep(data, labels, returnCost = true) {
  // Calling optimizer.minimize will adjust the variables in the
  // model based on the loss value returned by your loss function.
  // It handles all the backpropogation and weight updates.
  const cost = optimizer.minimize(() => {
    // Any variables used in this inference function will be optimized
    // by the optimizer.

    // Make a prediction using the current state of the model
    const prediction = inference(data);

    // Compute loss of the current model and return it. Calculating this loss
    // should involve the variables we are trying to optimize.
    //
    // Once we return the less the optimizer will adjust the network
    // weights for our next iteration.
    return loss(prediction, labels);
  }, returnCost);

  // return the current loss/cost so that we can visualize it
  return cost;
}

/**
 * 训练模型.
 *
 * 通过循环调用上述单步训练 trainStep. 用 `await dl.nextFrame()` 避免阻塞浏览器
 *
 * 可在此加载、批处理、清洗你的数据
 */
function train(data) { }

Backends

该库提供了一些后台来执行本库的核心数学运算，目前我们有一个 CPU 后台和一个 WebGL 后台，deeplearn.js 只要浏览器支持，是默认使用 WebGL 后台。WebGL 后台使用的是计算机的 GPU，旨在执行快速和高度优化的线性代数内核。

若强制使用 CPU 后台，你可以程序开始处调用dl.setBackend('cpu')。

检查哪种后台正在被使用，可以调用dl.getBackend()。

WebGL 后台

在使用WebGL后台时，数学运算如dl.add() 会推入着色器程序到GPU上执行。不像在CPU后台中那样，这些操作是不阻塞的（尽管将数据从主内存移动到GPU内存会有一些开销）。

这些着色器程序从 WebGLTextures 读取和写入。在链接数学运算时，textures 可以留在GPU内存中，这对性能非常重要。

你可以通过调用 tensor 的 data() 方法，定期从 gpu 下载数据，这样你就可以在你的主 Javascript 线程中读取这些数据。

获取两个矩阵之间均方差的例子：

const a = dl.tensor2d([[1.0, 2.0], [3.0, 4.0]]);
const b = dl.tensor2d([[0.0, 2.0], [4.0, 6.0]]);

// All these operations will execute on the GPU (if available)
// without blocking the main thread.
const diff = dl.sub(a, b);

// Calling .data returns a promise that resolves to a TypedArray that holds
// the tensor data downloaded from the GPU.
diff.data().then(d => console.log('difference: ' + d));
// We could also use dataSync to do this synchronously.
console.log('difference: ' + diff.dataSync());

TIP: Avoid calling data()/dataSync() between mathematical GPU operations unless you are debugging. This forces a texture download, and subsequent operation calls will have to re-upload the data to a new texture.

CPU 后台

在使用CPU实现时，这些数学运算会阻塞，然后立即在主 JavaScript 线程隐含的 TypedArray 上执行 。

相同的操作在两种后台中都被实现，因此你的代码无需根据客户端上使用的后台进行更改。

想了解更多？请阅读这些教程。