利用js 机器学习_js 实现利用机器码加密 - CSDN
  • 在过去的几年里,机器学习的...web生态系统虽然最近一直在取得进步,但是在机器学习领域JavaScropt和Node.js相对Python和Java来说还是稍弱,但是现在它们已经有足够的能力来处理机器学习方法的问题了。Web语言也有一

    在过去的几年里,机器学习的开发库增长很快,可用性也变得越来越可靠,而且没有减慢的趋势。一直以来Python作为机器学习的主力语言,现在神经网络可以应用任何语言了,包括JavaScript!

    web生态系统虽然最近一直在取得进步,但是在机器学习领域JavaScropt和Node.js相对Python和Java来说还是稍弱,但是现在它们已经有足够的能力来处理机器学习方法的问题了。Web语言也有一个优势,就是你所有的JavaScript机器学习工程只需要浏览器支持。

    现在大部分JavaScript机器学习的库都比较新而且有的还一直在开发中,但是已经实现并且可以尝试使用了。这篇文章我们将一起来了解这些库,一些比较酷的AI的web应用你也可以上手试试。

    1. Brain

    Brain是一个容易创建神经网络的库,你可以基于它的输入/输出数据来训练。因为训练需要大量的数据资源,虽然有CDN的链接可以通过网络直接加载到网页上。但还是推荐使用Node.js的环境来运行这个库。这里是一个 例子 ,在它们的网站上,被训练来识别颜色的对比。

    2. Deep playground

    带有教育性质的web应用让你参与神经网络的世界,并探索它们不同的组件。它有一个不错的UI, 让你来控制数据的输入,神经元的数量,用什么样的算法,还有其它大量的可调参数来影响最终的结果。还有大量的可以从应用中的场景中学习的东西 — 代码是开源的,而且用了一个可定义的 机器学习库 , 这个库是基于TypeScript并且有丰富的文档可查阅。

    3. FlappyLearning

    FlappyLearning是一个JavaScript项目,大概仅仅800行未合并压缩的代码,创建了一个机器学习的库来实现了一个很好玩的例子来玩 Flappy Bird 。这个库里用的人工智能技术叫 Neuroevolution 应用了比较自然的一些神经系统算法,根据每次迭代的成功和失败来动态的学习。这个例子非常容易运行— 用浏览器打开index.html文件就可以了。

    4. Synaptic

    可能是这个列表里最活跃的项目了, Synaptic是一个Node.js和浏览器可用的库,它是一个不可知结构,允许开发者构建任何类型的神经网络。它有一些构建好的结构,来让它可以更快速的测试和对比不同的机器学习算法。同样有比较完善的介绍和文档,一些练习的例子,还有很多非常棒的指导来理解机器学习是怎么工作的。

    5. Land Lines

    Land Lines是一个非常有趣的Chrome Web尝试,来找到地球的卫星图片。类似让用户来涂鸦。这个应用没有任何的服务端请求:它整个都运行在浏览器,要多亏机器学习的聪明使用,和WebGL的非常棒的性能表现,甚至在移动设备上。你可以在这里找到源码 GitHub 或阅读整个 案例 。

    6. ConvNetJS

    虽然不再积极的被维护了,ConvNetJS是最深入的JavaScript学习库。最初在斯坦福大学里被开发,ConvNetJS在GitHub上变得非常流行,许多社区开始驱动新的特性和指导手册。它直接在浏览器运行,支持多个学习技术,并且它非常的初级,更适合人们更多的体验神经网络。

    7. Thing Translator

    Thing Translator是一个网页实验,让你的手机用不同的语言来识别现实对象。这个应用完全应用web技术并且整合了Google的两个机器学习的API - Cloud Vision 来做图片识别, Translate API 来做 神经语言翻译。

    8. Neurojs

    构建AI系统基于强化学习的框架。可惜的是,这个开源项目并没有合适的文档。但是其中的例子,一个汽车自动驾驶的实验,有对构造神经网络的不同部分的详细描述。这个库是纯JavaScript语言并且应用了webpack和babel。

    9. Machine Learning

    另外的一个可以只用JavaScript来构建并训练神经网络的库。非常容易的安装,需要Nodejs和客户端,对于开发人员非常容易上手的API调用。这个库提供了大量的 示例 来实现了当下流行的算法,帮助来理解核心的机器学习的原则。

    10. DeepForge

    DeepForge是一个用户友好的开发环境来使用深度学习。允许自己用一些图形接口来设计神经网络,支持远程机器的训练模型,并有版本控制。项目运行在浏览器,并基于Node.js和MongoDB,安装过程对于web开发人员非常熟悉。

    非常优秀的博客文章,由Burank Kanber撰写,主要是关于机器学习的基础原理。非常适合JavaScript开发人员的阅读和学习。如果你想深入了解机器学习,这是一个非常棒的资源,推荐给大家。

    总结 虽然基于JavaScript的机器学习生态并没有充分的开发出来,我们推荐这些是你开始了解机器学习和核心技术的的非常好的资源。文中列出的试验性的项目,你可以仅使用浏览器或者一些JavaScript代码,就能探索出非常多好玩的东西。

    展开全文
  • TensorFlow.js 是一个 JavaScript 库,用于在浏览器和 Node.js 训练和部署机器学习模型。 了解开始的更多方式,请参阅下面的部分。 在不直接处理张量的情况下编写 ML 程序 想要开始机器学习,同时不用担心任何...

    开始

    TensorFlow.js 是一个 JavaScript 库,用于在浏览器和 Node.js 训练和部署机器学习模型。

    了解开始的更多方式,请参阅下面的部分。

     

    在不直接处理张量的情况下编写 ML 程序

    想要开始机器学习,同时不用担心任何类似张量或优化器的低级细节吗?

    ml5.js 库构建在 TensorFlow.js 之上,通过简洁的、可利用的 API,可以在浏览器中访问机器学习算法和模型。

    Check out ml5.js

     

    安装 TensorFlow.js

    TensorFlow.js 与 Tensors (张量)、Layers (图层)、Optimizers (优化器) 和损失函数等概念兼容(或希望与它们兼容)吗?TensorFlow.js 为 JavaScript 中神经网络编程提供了灵活的构建块。

    请参阅如何在浏览器或 Node.js 中启动和运行 TensorFlow.js 代码。

    Get Setup

     

    将预训练模型转换到 TensorFlow.js

    学习如何将预训练模型从 python 转换为 TensorFlow.js

    Keras Model GraphDef Model

     

    从现有 TensorFlow.js 代码中学习

    tfjs-examples 提供了使用 TensorFlow.js 实现各种 ML 任务的简短代码示例。

    See it on GitHub

     

    可视化您的 TensorFlow.js 模型的状态

    tfjs-vis 是一个用于在浏览器内实现可视化的小型库,用于TensorFlow.js。

    See it on GitHub See Demo

     

    准备好用 TensorFlow.js 处理数据

    TensorFlow.js 支持使用 ML 最佳实践处理数据。

    See docs

     

    安装

    浏览器安装

    在您基于浏览器的项目中获取TensorFlow.js有以下两种主要方法

    如果您不熟悉Web开发,或者从未听说过webpack或parcel等工具,我们建议您使用脚本标签(script tags)。如果您经验丰富或想要编写更大的程序,那么使用构建工具进行探索可能更加合适。

     

    使用脚本标签(script tags)

    将以下脚本标签添加到您的主HTML文件中:

    <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@1.0.0/dist/tf.min.js"></script>
    

    有关脚本标签的设置,请参阅代码示例:

    See code sample script tag setup

     

    从NPM安装

    您可以使用 npm cli工具或是yarn安装TensorFlow.js。

    yarn add @tensorflow/tfjs
    

     

    npm install @tensorflow/tfjs
    

     

    See sample code for installation via NPM

     

    Node.js 安装

    您可以使用 npm cli工具或是yarn安装TensorFlow.js。

    选项1: 安装带有原生C++绑定的TensorFlow.js。

    yarn add @tensorflow/tfjs-node
    

     

    npm install @tensorflow/tfjs-node
    

     

    选项2: (仅限Linux)如果您的系统具有支持CUDA的NVIDIA®GPU,请使用GPU包以获得更高的性能。

    yarn add @tensorflow/tfjs-node-gpu
    

     

    npm install @tensorflow/tfjs-node-gpu
    

     

    选项3: 安装纯JavaScript版本,这是性能方面最慢的选项。

    yarn add @tensorflow/tfjs
    

     

    npm install @tensorflow/tfjs
    

     

    See sample code for Node.js usage

    TypeScript

    当使用TypeScript时,如果您的项目使用严格的空值检查,或者在编译过程中遇到错误,则您可能需要在您的tsconfig.json文件中设置skipLibCheck:true

     

    从二维数据进行预测

    在这个教程中你将使用一组汽车的数字数据集训练一个模型并且预测。

    本练习将演示训练许多不同类型模型的常用步骤,但将使用小数据集和简单(浅)模型。 主要目的是帮助您熟悉TensorFlow.js训练模型的基本术语、概念和语法 并为进一步的探索和学习提供一个垫脚石。

    打开Codelab

     

    使用卷积神经网络进行手写数字识别

    在这个教程中,我们将会使用Tensorflow.js建立手写数字识别卷积神经网络模型。首先,我们训练分类器,让它查看数千个图像以及其标签。然后我们将使用模型从未见过的测试数据来评估分类器的准确性。

    在 CodeLab 中打开

     

    Tensorflow.js 张量和变量

    张量(Tensor)和变量(Variable)是TensorFlow.js中数据的主要表现形式,两者不同之处在于张量是不可变的,而变量是可变的。

     

    张量(Tensor)

    TensorFlow.js中数据的中心单位是张量:一组数值形成一个或多个维度的数组。 张量实例具有定义数组形状的形状属性。

    Tensorflow.js中数据的主要表现形式就是tensor(张量):由 一组数值形成一维或多维数组。一个Tensor实例有一个shape属性来定义这一组数值如何组成张量,而最主要的Tensor实例的构造函数就是 tf.tensor 函数,如下所示:

    // 2x3 Tensor
    const shape = [2, 3]; // 2 行, 3 列
    const a = tf.tensor([1.0, 2.0, 3.0, 10.0, 20.0, 30.0], shape);
    a.print(); // 打印张量值
    // 输出:    [[1 , 2 , 3 ],
    //          [10, 20, 30]]
    
    // shape也可以用下面的方式实现:
    const b = tf.tensor([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]]);
    b.print();
    // 输出:    [[1 , 2 , 3 ],
    //          [10, 20, 30]]
    

    但是,为了构造低秩张量,我们推荐使用下面的函数来增强代码的可读性:tf.scalar(零维), tf.tensor1d(一维), tf.tensor2d(二维), tf.tensor3d(三维)、tf.tensor4d(四维)以及 tf.ones(值全是1)或者tf.zeros(值全是0) ,如下所示:

    const a = tf.scalar(3.14);
    a.print(); // 输出零维张量
    
    const b = tf.tensor2d([[2, 3, 4], [5, 6, 7]]);
    b.print(); // 输出二维张量
    
    const c = tf.zeros([2, 3]);
    c.print(); // 输出2行3列的值全是0的张量
    
    const d = tf.ones([3, 5]);
    d.print(); // 输出3行5列的值全是1的张量

    在TensorFlow.js中,张量是不变的; 一旦创建你就不能改变它们的值。 但是,您可以对它们执行操作来生成新的张量。

     

    变量(Variable)

    Variables变量是通过张量进行初始化得到的。不像Tensor的值不可变,变量的值是可变的。你可以使用变量的assign方法分配一个新的tensor到这个变量上,这是变量就会改变

    const initialValues = tf.zeros([5]);
    const biases = tf.variable(initialValues); // 初始化biases
    biases.print(); // 输出: [0, 0, 0, 0, 0]
    
    const updatedValues = tf.tensor1d([0, 1, 0, 1, 0]);
    biases.assign(updatedValues); // 更新 biases的值
    biases.print(); // 输出: [0, 1, 0, 1, 0]
    

    如上所示,首先使用tf.zeros得到一个张量,然后利用这个张量初始化得到一个变量,接着我们就可以打印这个变量,并且通Object.prototype.toString.call(biases)方法可以判断变量也是一个对象,接着,我们再生成一个张量,然后变量调用assign方法传入这个张量,就可以得到一个新的变量了,如下

    11

    由此我们可以得出一个结论:变量由张量生成,且张量不可变而变量可变。

     

    以上就是Tensorflow.js 张量和变量的相关介绍,希望对大家有所帮助。

     

    Tensorflow.js 模型

    在Tensorflow.js中,从概念上来说,一个模型就是一个给定一些输入将会产生特定的输出的函数。简单来说,一个模型就是一个函数,只是它完成了特定的任务。

    在TensorFlow.js中有两种方式来创建模型,一种是通过操作(ops)来直接完成模型本身所做的工作,另外一种就是通过高级API tf.model来创建一个模型,显然第二种是更容易的。

    我们先看第一种创建模型的方法:

    function predict(input) {
      // y = a * x ^ 2 + b * x + c
      // More on tf.tidy in the next section
      return tf.tidy(() => {
        const x = tf.scalar(input);
    
        const ax2 = a.mul(x.square());
        const bx = b.mul(x);
        const y = ax2.add(bx).add(c);
    
        return y;
      });
    }
    
    const a = tf.scalar(2);
    const b = tf.scalar(4);
    const c = tf.scalar(8);
    
    const result = predict(2);
    result.print() 
    

    如上所示,我们定义的predict函数就是一个模型,对于给定的输入,我们就可以得到预测的输出。注意:所有的数字都需要经过tf.scalar()张量处理。

     

    而第二种创建模型的方法就是用 TensorFlow.js 中的 tf.model 方法(这里的model并不是真正可以调用的方法,而是一个总称,比如实际上可以调用的是tf.sequential模型),这在深度学习中是非常流行的概念。 下面的代码就创建了 tf.sequential 模型:

    const model = tf.sequential();
    model.add(
      tf.layers.simpleRNN({
        units: 20,
        recurrentInitializer: 'GlorotNormal',
        inputShape: [80, 4]
      })
    );
    
    const optimizer = tf.train.sgd(LEARNING_RATE);
    model.compile({optimizer, loss: 'categoricalCrossentropy'});
    model.fit({x: data, y: labels)});

    以上就是TensorFlow.js模型创建的两种方法介绍,希望对大家有所帮助。

     

    Tensorflow.js 内存管理

    因为TensorFlow.js使用了GPU来加速数学运算,因此当tensorflow处理张量和变量时就有必要来管理GPU内存。在TensorFlow.js中,我们可以通过dispose 和 tf.tidy这两种方法来管理内存。

     

    dispose

    您可以在张量或变量上调用dispose来清除它并释放其GPU内存:

    const x = tf.tensor2d([[0.0, 2.0], [4.0, 6.0]]);
    const x_squared = x.square();
    
    x.dispose();
    x_squared.dispose();
    

     

    tf.tidy

    进行大量的张量操作时使用dispose可能会很麻烦。 TensorFlow.js提供了另一个函数tf.tidy,它对JavaScript中的常规范围起到类似的作用,不同的是它针对GPU支持的张量。

    tf.tidy执行一个函数并清除所有创建的中间张量,释放它们的GPU内存。 它不清除内部函数的返回值。

    const average = tf.tidy(() => {
      const y = tf.tensor1d([1.0, 2.0, 3.0, 4.0]);
      const z = tf.ones([4]);
    
      return y.sub(z).square().mean();
    });
    
    average.print()
    

    使用tf.tidy将有助于防止应用程序中的内存泄漏。它也可以用来更谨慎地控制内存何时回收。

     

    两个重要的注意事项

    传递给tf.tidy的函数应该是同步的,并且不会返回Promise。我们建议在tf.tidy内不要有更新UI或在发出远程请求的代码。

    tf.tidy不会清理变量。变量通常持续到机器学习模型的整个生命周期,因此TensorFlow.js不会清理它们,即使它们是在tidy中创建的。不过,您可以手动调用dispose处理它们。

     

     

     

    Tensorflow.js 拟合曲线

    这篇文章中,我们将使用TensorFlow.js来根据数据拟合曲线。即使用多项式产生数据然后再改变其中某些数据(点),然后我们会训练模型来找到用于产生这些数据的多项式的系数。简单的说,就是给一些在二维坐标中的散点图,然后我们建立一个系数未知的多项式,通过TensorFlow.js来训练模型,最终找到这些未知的系数,让这个多项式和散点图拟合。

     

    先决条件

    本教程假定您熟悉核心概念中介绍的TensorFlow.js的基本构建块:张量,变量和操作。 我们建议在完成本教程之前先完成核心概念的学习。

     

    运行代码

    这篇文章关注的是创建模型以及学习模型的系数,完整的代码在这里可以找到。为了在本地运行,如下所示:

    $ git clone https://github.com/tensorflow/tfjs-examples
    $ cd tfjs-examples/polynomial-regression-core
    $ yarn
    $ yarn watch
    

    即首先将核心代码下载到本地,然后进入polynomial-regression-core(即多项式回归核心)部分,最后进行yarn安装并运行。

     

    输入数据

    我们的数据集由x坐标和y坐标组成,当绘制在笛卡尔平面上时,其坐标如下所示:

    1

     

    该数据是由三次方程 y = ax^{3}+ bx^{2} + cx + d 生成的。

    我们的任务是学习这个函数的a,b,c和d系数以最好地拟合数据。 我们来看看如何使用TensorFlow.js操作来学习这些值。

     

    学习步骤

    第1步:设置变量

    首先,我们需要创建一些变量。即开始我们是不知道a、b、c、d的值的,所以先给他们一个随机数,入戏所示:

    const a = tf.variable(tf.scalar(Math.random()));
    const b = tf.variable(tf.scalar(Math.random()));
    const c = tf.variable(tf.scalar(Math.random()));
    const d = tf.variable(tf.scalar(Math.random()));
    

     

    第2步:建立模型

    我们可以通过TensorFlow.js中的链式调用操作来实现这个多项式方程  y = ax3 + bx2 + cx + d,下面的代码就创建了一个 predict 函数,这个函数将x作为输入,y作为输出:

    function predict(x) {
      // y = a * x ^ 3 + b * x ^ 2 + c * x + d
      return tf.tidy(() => {
        return a.mul(x.pow(tf.scalar(3))) // a * x^3
          .add(b.mul(x.square())) // + b * x ^ 2
          .add(c.mul(x)) // + c * x
          .add(d); // + d
      });
    }
    

    其中,在上一篇文章中,我们讲到tf.tify函数用来清除中间张量,其他的都很好理解。

    接着,让我们把这个多项式函数的系数使用之前得到的随机数,可以看到,得到的图应该是这样:

    2

     

    因为开始时,我们使用的系数是随机数,所以这个函数和给定的数据匹配的非常差,而我们写的模型就是为了通过学习得到更精确的系数值。

     

    第3步:训练模型

    最后一步就是要训练这个模型使得系数和这些散点更加匹配,而为了训练模型,我们需要定义下面的三样东西:

    • 损失函数(loss function):这个损失函数代表了给定多项式和数据的匹配程度。 损失函数值越小,那么这个多项式和数据就跟匹配。
    • 优化器(optimizer):这个优化器实现了一个算法,它会基于损失函数的输出来修正系数值。所以优化器的目的就是尽可能的减小损失函数的值。
    • 训练迭代器(traing loop):即它会不断地运行这个优化器来减少损失函数。

    所以,上面这三样东西的 关系就非常清楚了: 训练迭代器使得优化器不断运行,使得损失函数的值不断减小,以达到多项式和数据尽可能匹配的目的。这样,最终我们就可以得到a、b、c、d较为精确的值了。

     

    定义损失函数

    这篇文章中,我们使用MSE(均方误差,mean squared error)作为我们的损失函数。MSE的计算非常简单,就是先根据给定的x得到实际的y值与预测得到的y值之差 的平方,然后在对这些差的平方求平均数即可

    1044137-20180415120225981-2029551102

    于是,我们可以这样定义MSE损失函数:

    function loss(predictions, labels) {
      // 将labels(实际的值)进行抽象
      // 然后获取平均数.
      const meanSquareError = predictions.sub(labels).square().mean();
      return meanSquareError;
    }

    即这个损失函数返回的就是一个均方差,如果这个损失函数的值越小,显然数据和系数就拟合的越好。

     

    定义优化器

    对于我们的优化器而言,我们选用 SGD (Stochastic Gradient Descent)优化器,即随机梯度下降。SGD的工作原理就是利用数据中任意的点的梯度以及使用它们的值来决定增加或者减少我们模型中系数的值。

    TensorFlow.js提供了一个很方便的函数用来实现SGD,所以你不需要担心自己不会这些特别复杂的数学运算。 即 tf.train.sdg 将一个学习率(learning rate)作为输入,然后返回一个SGDOptimizer对象,它与优化损失函数的值是有关的。

    在提高它的预测能力时,学习率(learning rate)会控制模型调整幅度将会有多大。低的学习率会使得学习过程运行的更慢一些(更多的训练迭代获得更符合数据的系数),而高的学习率将会加速学习过程但是将会导致最终的模型可能在正确值周围摇摆。简单的说,你既想要学的快,又想要学的好,这是不可能的。

    下面的代码就创建了一个学习率为0.5的SGD优化器。

    const learningRate = 0.5;
    const optimizer = tf.train.sgd(learningRate);
    

     

    定义训练循环

    既然我们已经定义了损失函数和优化器,那么现在我们就可以创建一个训练迭代器了,它会不断地运行SGD优化器来使不断修正、完善模型的系数来减小损失(MSE)。下面就是我们创建的训练迭代器:

    function train(xs, ys, numIterations = 75) {
    
      const learningRate = 0.5;
      const optimizer = tf.train.sgd(learningRate);
    
      for (let iter = 0; iter < numIterations; iter++) {
        optimizer.minimize(() => {
          const predsYs = predict(xs);
          return loss(predsYs, ys);
        });
      }
    

    现在,让我们一步一步地仔细看看上面的代码。首先,我们定义了训练函数,并且以数据中x和y的值以及制定的迭代次数作为输入:

    function train(xs, ys, numIterations) {
    ...
    }
    

    接下来,我们定义了之前讨论过的学习率(learning rate)以及SGD优化器:

    const learningRate = 0.5;
    const optimizer = tf.train.sgd(learningRate);
    

    最后,我们定义了一个for循环,这个循环会运行numIterations次训练。在每一次迭代中,我们都调用了optimizer优化器的minimize函数,这就是见证奇迹的地方:

    for (let iter = 0; iter < numIterations; iter++) {
      optimizer.minimize(() => {
        const predsYs = predict(xs);
        return loss(predsYs, ys);
      });
    }
    

    minimize 接受了一个函数作为参数,这个函数做了下面的两件事情:

    1、首先它对所有的x值通过我们在之前定义的pridict函数预测了y值。

    2、然后它通过我们之前定义的损失函数返回了这些预测的均方误差。

    minimize函数之后会自动调整这些变量(即系数a、b、c、d)来使得损失函数更小。

    在运行训练迭代器之后,a、b、c以及d就会是通过模型75次SGD迭代之后学习到的结果了。 

    查看结果!

    一旦程序运行结束,我们就可以得到最终的a、b、c和d的结果了,然后使用它们来绘制曲线,如下所示:

    3

    这个结果已经比开始随机分配系数的结果拟合的好得多了!

     

     

     

    Tensorflow.js 图片训练

    这篇文章中,我们将使用CNN构建一个Tensorflow.js模型来分辨手写的数字。首先,我们通过使之“查看”数以千计的数字图片以及他们对应的标识来训练分辨器。然后我们再通过此模型从未“见到”过的测试数据评估这个分辨器的精确度。

     

    一、运行代码

    这篇文章的全部代码可以在仓库TensorFlow.js examples 中的tfjs-examples/mnist 下找到,你可以通过下面的方式clone下来然后运行这个demo:

    $ git clone https://github.com/tensorflow/tfjs-examples
    $ cd tfjs-examples/mnist
    $ yarn
    $ yarn watch

    上面的这个目录完全是独立的,所以完全可以copy下来然后创建你个人的项目。

     

    二、数据相关

    这里我们将会使用  MNIST  的手写数据,这些我们将要去分辨的手写数据如下所示:

    11

    为了预处理这些数据,我们已经写了 data.js, 这个文件包含了Minsdata类,而这个类可以帮助我们从MNIST的数据集中获取到任意的一些列的MNIST。

    而MnistData这个类将全部的数据分割成了训练数据和测试数据。我们训练模型的时候,分辨器就会只观察训练数据。而当我们评价模型时,我们就仅仅使用测试数据,而这些测试数据是模型还没有看见到的,这样就可以来观察模型预测全新的数据了。

    这个MnistData有两个共有方法:

    1、nextTrainBatch(batchSize): 从训练数据中返回一批任意的图片以及他们的标识。

    2、nextTestBatch(batchSize):  从测试数据中返回一批图片以及他们的标识。

    注意:当我们训练MNIST分辨器时,应当注意数据获取的任意性是非常重要的,这样模型预测才不会受到我们提供图片顺序的干扰。例如,如果我们每次给这个模型第一次都提供的是数字1,那么在训练期间,这个模型就会简单的预测第一个就是1(因为这样可以减小损失函数)。 而如果我们每次训练时都提供的是2,那么它也会简单切换为预测2并且永远不会预测1(同样的,也是因为这样可以减少损失函数)。如果每次都提供这样典型的、有代表性的数字,那么这个模型将永远也学不会做出一个精确的预测。

     

    三、创建模型

    在这一部分,我们将会创建一个卷积图片识别模型。为了这样做,我们使用了Sequential模型(模型中最为简单的一个类型),在这个模型中,张量(tensors)可以连续的从一层传递到下一层中。

      首先,我们需要使用tf.sequential先初始化一个sequential模型:

    const model = tf.sequential();

    既然我们已经创建了一个模型,那么我们就可以添加层了。

     

    四、添加第一层

    我们要添加的第一层是一个2维的卷积层。卷积将过滤窗口掠过图片来学习空间上来说不会转变的变量(即图片中不同位置的模式或者物体将会被平等对待)。

    我们可以通过tf.layers.conv2d来创建一个2维的卷积层,这个卷积层可以接受一个配置对象来定义层的结构,如下所示:

    model.add(tf.layers.conv2d({
      inputShape: [28, 28, 1],
      kernelSize: 5,
      filters: 8,
      strides: 1,
      activation: 'relu',
      kernelInitializer: 'VarianceScaling'
    }));

    让我们拆分对象中的每个参数吧:

    • inputShape。这个数据的形状将回流入模型的第一层。在这个示例中,我们的MNIST例子是28 x 28像素的黑白图片,这个关于图片的特定的格式即[row, column, depth],所以我们想要配置一个[28, 28, 1]的形状,其中28行和28列是这个数字在每个维度上的像素数,且其深度为1,这是因为我们的图片只有1个颜色:
    • kernelSize。划过卷积层过滤窗口的数量将会被应用到输入数据中去。这里,我们设置了kernalSize的值为5,也就是指定了一个5 x 5的卷积窗口。
    • filters。这个kernelSize的过滤窗口的数量将会被应用到输入数据中,我们这里将8个过滤器应用到数据中。
    • strides。 即滑动窗口每一步的步长。比如每当过滤器移动过图片时将会由多少像素的变化。这里,我们指定其步长为1,这意味着每一步都是1像素的移动。
    • activation。这个activation函数将会在卷积完成之后被应用到数据上。在这个例子中,我们应用了relu函数,这个函数在机器学习中是一个非常常见的激活函数。
    • kernelInitializer。这个方法对于训练动态的模型是非常重要的,他被用于任意地初始化模型的weights。我们这里将不会深入细节来讲,但是 VarianceScaling (即这里用的)真的是一个初始化非常好的选择。

     

    五、添加第二层  

    让我们为这个模型添加第二层:一个最大的池化层(pooling layer),这个层中我们将通过 tf.layers.maxPooling2d 来创建。这一层将会通过在每个滑动窗口中计算最大值来降频取样得到结果。

    model.add(tf.layers.maxPooling2d({
      poolSize: [2, 2],
      strides: [2, 2]
    }));
    • poolSize。这个滑动池窗口的数量将会被应用到输入的数据中。这里我们设置poolSize为[2, 2],所以这就意味着池化层将会对输入数据应用2x2的窗口。
    • strides。 这个池化层的步长大小。比如,当每次挪开输入数据时窗口需要移动多少像素。这里我们指定strides为[2, 2],这就意味着过滤器将会以在水平方向和竖直方向上同时移动2个像素的方式来划过图片。

      注意:因为poolSize和strides都是2x2,所以池化层空口将会完全不会重叠。这也就意味着池化层将会把激活的大小从上一层减少一半。

     

    六、添加剩下的层

    重复使用层结构是神经网络中的常见模式。我们添加第二个卷积层到模型,并在其后添加池化层。请注意,在我们的第二个卷积层中,我们将滤波器数量从8增加到16。还要注意,我们没有指定inputShape,因为它可以从前一层的输出形状中推断出来:

    model.add(tf.layers.conv2d({
      kernelSize: 5,
      filters: 16,
      strides: 1,
      activation: 'relu',
      kernelInitializer: 'VarianceScaling'
    }));
    
    model.add(tf.layers.maxPooling2d({
      poolSize: [2, 2],
      strides: [2, 2]
    }));
    

    接下来,我们添加一个 flatten层,将前一层的输出平铺到一个向量中:

    model.add(tf.layers.flatten());
    

    最后,让我们添加一个 dense层(也称为全连接层),它将执行最终的分类。 在dense层前先对卷积+池化层的输出执行flatten也是神经网络中的另一种常见模式:

    model.add(tf.layers.dense({
      units: 10,
      kernelInitializer: 'VarianceScaling',
      activation: 'softmax'
    }));
    

    我们来分析传递给dense层的参数。

    • units. 激活输出的数量。由于这是最后一层,我们正在做10个类别的分类任务(数字0-9),因此我们在这里使用10个units。 (有时units被称为神经元的数量,但我们会避免使用该术语。)
    • kernelInitializer. 我们将对dense层使用与卷积层相同的VarianceScaling初始化策略。
    • activation. 分类任务的最后一层的激活函数通常是 softmax。 Softmax将我们的10维输出向量归一化为概率分布,使得我们10个类中的每个都有一个概率值。

     

    定义优化器

    对于我们的卷积神经网络模型,我们将使用学习率为0.15的随机梯度下降(SGD)优化器:

    const LEARNING_RATE = 0.15;
    const optimizer = tf.train.sgd(LEARNING_RATE);
    

     

    定义损失函数

    对于损失函数,我们将使用通常用于优化分类任务的交叉熵( categoricalCrossentropy)。 categoricalCrossentropy度量模型的最后一层产生的概率分布与标签给出的概率分布之间的误差,这个分布在正确的类标签中为1(100%)。 例如,下面是数字7的标签和预测值:

    |class | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | |----------|---|---|---|---|---|---|---|---|---|---| |label | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | |prediction|.1 |.01|.01|.01|.20|.01|.01|.60|.03|.02|

    如果预测的结果是数字7的概率很高,那么categoricalCrossentropy会给出一个较低的损失值,而如果7的概率很低,那么categoricalCrossentropy的损失就会更高。在训练过程中,模型会更新它的内部参数以最小化在整个数据集上的categoricalCrossentropy。

     

    定义评估指标

    对于我们的评估指标,我们将使用准确度,该准确度衡量所有预测中正确预测的百分比。

     

    编译模型

    为了编译模型,我们传入一个由优化器,损失函数和一系列评估指标(这里只是'精度')组成的配置对象:

    model.compile({
      optimizer: optimizer,
      loss: 'categoricalCrossentropy',
      metrics: ['accuracy'],
    });
    

     

    配置批量大小

    在开始训练之前,我们需要定义一些与batch size相关的参数:

    const BATCH_SIZE = 64;
    const TRAIN_BATCHES = 100;
    const TEST_BATCH_SIZE = 1000;
    const TEST_ITERATION_FREQUENCY = 5;
    

     

    进一步了解分批量和批量大小

    为了充分利用GPU并行化计算的能力,我们希望将多个输入批量处理,并使用单个前馈网络调用将他们馈送到网络。

    我们批量计算的另一个原因是,在优化过程中,我们只能在对多个样本中的梯度进行平均后更新内部参数(迈出一步)。这有助于我们避免因错误的样本(例如错误标记的数字)而朝错误的方向迈出了一步。

    当批量输入数据时,我们引入秩D + 1的张量,其中D是单个输入的维数。

    如前所述,我们MNIST数据集中单个图像的维度为[28,28,1]。当我们将BATCH_SIZE设置为64时,我们每次批量处理64个图像,这意味着我们的数据的实际形状是[64,28,28,1](批量始终是最外层的维度)。

    注意:*回想一下在我们的第一个conv2d配置中的inputShape没有指定批量大小(64)。 Config被写成批量大小不可知的,以便他们能够接受任意大小的批次。

     

    编写训练循环

    以下是训练循环的代码:

    for (let i = 0; i < TRAIN_BATCHES; i++) {
      const batch = data.nextTrainBatch(BATCH_SIZE);
     
      let testBatch;
      let validationData;
    
      if (i % TEST_ITERATION_FREQUENCY === 0) {
        testBatch = data.nextTestBatch(TEST_BATCH_SIZE);
        validationData = [
          testBatch.xs.reshape([TEST_BATCH_SIZE, 28, 28, 1]), testBatch.labels
        ];
      }
     
      const history = await model.fit(
          batch.xs.reshape([BATCH_SIZE, 28, 28, 1]),
          batch.labels,
          {
            batchSize: BATCH_SIZE,
            validationData,
            epochs: 1
          });
    
      const loss = history.history.loss[0];
      const accuracy = history.history.acc[0];
    
    }
    

    让我们分析代码。 首先,我们获取一批训练样本。 回想一下上面说的,我们利用GPU并行化批量处理样本,在对大量样本进行平均后才更新参数:

    const batch = data.nextTrainBatch(BATCH_SIZE);
    
    • 每5个step(TEST_ITERATION_FREQUENCY),我们构造一次validationData,这是一个包含一批来自MNIST测试集的图像及其相应标签这两个元素的数组,我们将使用这些数据来评估模型的准确性:
    if (i % TEST_ITERATION_FREQUENCY === 0) {
      testBatch = data.nextTestBatch(TEST_BATCH_SIZE);
      validationData = [
        testBatch.xs.reshape([TEST_BATCH_SIZE, 28, 28, 1]),
        testBatch.labels
      ];
    }
    

    model.fit是模型训练和参数实际更新的地方。

    注意:在整个数据集上执行一次model.fit会导致将整个数据集上传到GPU,这可能会使应用程序死机。 为避免向GPU上传太多数据,我们建议在for循环中调用model.fit(),一次传递一批数据,如下所示:

      const history = await model.fit(
          batch.xs.reshape([BATCH_SIZE, 28, 28, 1]), batch.labels,
          {batchSize: BATCH_SIZE, validationData: validationData, epochs: 1});
    

    我们再来分析一下这些参数:

    • X. 输入图像数据。请记住,我们分批量提供样本,因此我们必须告诉fit函数batch有多大。 MnistData.nextTrainBatch返回形状为[BATCH_SIZE,784]的图像 —— 所有的图像数据是长度为784(28 * 28)的一维向量。但是,我们的模型预期图像数据的形状为[BATCH_SIZE,28,28,1],因此我们需要使用reshape函数。
    • y. 我们的标签;每个图像的正确数字分类。
    • BATCHSIZE. 每个训练batch中包含多少个图像。之前我们在这里设置的BATCH_SIZE是64。
    • validationData. 每隔TEST_ITERATION_FREQUENCY(这里是5)个Batch,我们构建的验证集。该数据的形状为[TEST_BATCH_SIZE,28,28,1]。之前,我们设置了1000的TEST_BATCH_SIZE。我们的评估度量(准确度)将在此数据集上计算。
    • epochs. 批量执行的训练次数。由于我们分批把数据馈送到fit函数,所以我们希望它每次仅从这个batch上进行训练。

    每次调用fit的时候,它会返回一个包含指标日志的对象,我们把它存储在history。我们提取每次训练迭代的损失和准确度,以便将它们绘制在图上:

    const loss = history.history.loss[0];
    const accuracy = history.history.acc[0];
    

     

    查看结果!

    如果你运行完整的代码,你应该看到这样的输出:

    v2-22a6180e611dc02770481d6de33f9396_hd

     

    TensorFlow.js 导入Keras模型

    Keras模型(通常通过Python API创建)的存储格式可以有多种, 其中“整个模型”(即架构+权重+优化器状态都存在一个文件内)格式可以转换为 TensorFlow.js Layers格式,可以直接加载到TensorFlow.js中进行推理或进一步训练。

    TensorFlow.js Layers格式是一个包含model.json文件和一组二进制格式的权重文件分片的目录。 model.json文件包含模型拓扑结构(又名“体系结构”或“图”:层的描述以及它们如何连接)以及权重文件的清单。

     

    要求

    运行模型格式转换程序需要Python环境;如果你想要一个独立的环境,你可以使用pipenv或virtualenv。要安装转换器,请使用这个命令 

    pip install tensorflowjs

    将Keras模型导入TensorFlow.js可以分为两个步骤。首先,将现有的Keras模型转换为TF.js Layers格式,然后将其加载到TensorFlow.js中。

     

    1、将Keras模型转换为TF.js Layers格式

    Keras模型通常使用model.save(filepath)保存,它生成一个包含模型拓扑结构和权重的HDF5(.h5)文件。要将这样的文件转换为TF.js Layer格式,请运行以下命令,其中path / to / my_model.h5是Keras .h5源文件,path / to / tfjs_target_dir是TF.js文件的输出目录:

    # bash
    
    tensorflowjs_converter --input_format keras \
                           path/to/my_model.h5 \
                           path/to/tfjs_target_dir
    

    这一步骤的另一个方案:使用Python API直接导出为TF.js Layers格式

    如果您在Python中使用Keras模型,则可以将其直接导出为TensorFlow.js Layers格式,如下所示:

    # Python
    
    import tensorflowjs as tfjs
    
    def train(...):
        model = keras.models.Sequential()   # for example
        ...
        model.compile(...)
        model.fit(...)
        tfjs.converters.save_keras_model(model, tfjs_target_dir)

     

    2、将模型加载到TensorFlow.js中

    使用Web服务器来为您在步骤1中生成的转换模型文件提供服务。请注意,为了允许JavaScript获取文件,您可能需要配置服务器以允许跨源资源共享(CORS)。

    然后通过提供model.json文件的URL将模型加载到TensorFlow.js中:

    // JavaScript
    
    import * as tf from '@tensorflow/tfjs';
    
    const model = await tf.loadModel('https://foo.bar/tfjs_artifacts/model.json');
    

    现在该模型已准备好进行推理,评估或重新训练。例如,加载的模型可以立即用于预测:

    // JavaScript
    
    const example = tf.fromPixels(webcamElement);  // for example
    const prediction = model.predict(example);
    

    TensorFlow.js Examples中的很多例子都采用此方法,使用已在Google云端存储上转换并托管的预训练模型。

    请注意,您使用model.json文件名来引用整个模型。 loadModel(...)获取model.json,然后发出额外的HTTP(S)请求以获取model.json权重清单中引用的权重文件分片。这种方法允许所有这些文件被浏览器缓存(也可能通过互联网上的其他缓存服务器),因为model.json和weight shard分别小于典型的缓存文件大小限制。因此,模型可能会在随后的场合更快加载。

     

    支持的功能

    TensorFlow.js Layers目前仅支持使用标准Keras构造的Keras模型。使用了不受支持的操作或层(例如自定义层,Lambda层,自定义损失或自定义指标)的模型将无法自动导入,因为它们所依赖的Python代码无法正确地转换为JavaScript。

     

    机器学习资源

    使用Tensorflow.js进行机器学习需要一些列不同的只是,尤其是机器学习,神经网络,Javascript,Node.js以及浏览器开发这些方面。取决于你的背景你可能对其中的一个或一些知识领域并不熟悉。这里有很多优秀的在线学习资源,本页将重点介绍一些资源,以帮助用神经网络引导您的机器学习知识。

     

    高水平介绍

    我们推荐您可以从下列视频获取高水平的深度学习以及Tensorflow.js的介绍。

     

    TensorFlow.js 介绍

    下列资源诸着重介绍了Tensorflow.js同时也涉及了机器学习的基本知识。

     

    综合课程

    下列是综合的深度学习在线课程。大部分课程使用python作为主要语言。然而,即使语法没有涉及但是这些概念也可以被转换在Tensorflow.js上。

     

    综合书籍

     

    数学概念

    机器学习是一门需要一定数学基础的学科,如果你只是需要使用机器学习模型,那么理解模型背后的数学原理是没有必要的。如果你计划调整机器学习模型或是从头建立一个模型,那么熟悉基本的数学概念对您是有帮助的。 你不必预先学习所有的数学知识,而是可以在遇到不熟悉的概念时查找并学习它们。

    展开全文
  • 虽然大部分机器学习都是用python这样的语言完成的,但在Javascript生态系统中,其前端和后端社区都很棒。这个有趣的交集促使我们探索并尝试了一起使用Javascript机器学习的奇怪可能性。这里分享有一些有趣的库,...

    https://www.toutiao.com/a6669159846014616071/

    虽然大部分机器学习都是用python这样的语言完成的,但在Javascript生态系统中,其前端和后端社区都很棒。这个有趣的交集促使我们探索并尝试了一起使用Javascript和机器学习的奇怪可能性。这里分享有一些有趣的库,它们将Javascript,机器学习,DNN甚至NLP结合在一起。

    2019年11个值得研究的Javascript机器学习库

     

    1. Brain.js

    2019年11个值得研究的Javascript机器学习库

     

    Brain.js是神经网络的Javascript库,取代了(现已弃用的)“ 大脑 ”库,可以与Node.js一起使用或在浏览器中使用(笔记计算),并为不同的任务提供不同类型的网络。

    Github地址:https://github.com/BrainJS/brain.js

    这是一个训练网络识别颜色对比的演示。

    2019年11个值得研究的Javascript机器学习库

     

    2. Synaptic

    Synaptic是一个用于node.js和浏览器的Javascript神经网络库,它使您能够训练第一级甚至二级神经网络架构。该项目包括一些内置架构,如多层感知器,多层长短期记忆网络,液体状态机和能够训练真实网络的培训师。

    Github地址:https://github.com/cazala/synaptic

    2019年11个值得研究的Javascript机器学习库

     

    3. Neataptic

    该库为浏览器和Node.js提供快速神经进化和反向传播,其中包括一些内置网络,包括感知器,LSTM,GRU,Nark等。这是一个简单培训的新手教程。

    Github地址:https://github.com/wagenaartje/neataptic

    2019年11个值得研究的Javascript机器学习库

     

    4. ConvNetJS

    由斯坦福大学博士开发,这个受欢迎的图书馆在过去的4年里一直没有得到维护,但绝对是名单上最有趣的项目之一。它是神经网络的Javascript实现,支持通用模块,分类,回归,实验强化学习模块,甚至能够训练处理图像的卷积网络。

    Github地址:https://github.com/karpathy/convnetjs

    它目前支持:

    • 常见的神经网络模块(完全连接的层,非线性)
    • 分类(SVM / Softmax)和回归(L2)成本函数
    • 能够指定和训练处理图像的卷积网络
    • 基于Deep Q Learning 的实验性强化学习模块

    2019年11个值得研究的Javascript机器学习库

     

    •  

    5. WebDNN

    这个日本制造的JavaScript库是为了在浏览器上快速运行深度神经网络预训练模型而构建的。由于在浏览器上执行DNN会消耗大量计算资源,因此该框架优化了DNN模型以压缩模型数据并通过JavaScript API(如WebAssembly和WebGPU)加速执行。

    2019年11个值得研究的Javascript机器学习库

     

    Github地址:https://github.com/mil-tokyo/webdnn

    利用WebDNN做神经网络风格转移的例子:

    2019年11个值得研究的Javascript机器学习库

     

    6. Deeplearnjs

    这个流行的库允许您在浏览器中训练神经网络或在推理模式下运行预先训练的模型,甚至声称它可以用作网络的NumPy。通过易于获取的API,该库可用于实用的有用应用程序,并且可以进行主动维护。

    Github地址:https://github.com/tensorflow/tfjs-core

    2019年11个值得研究的Javascript机器学习库

     

    作为TensorFlow.js生态系统的一部分,它如今托管在@tensorflow/tfjs-core了,是TensorFlow.js核心API,它提供低级,硬件加速的线性代数运算和用于自动区分的急切API。

    7. Tensorflow Deep Playground

    Tensorflow Deep Playground是神经网络的交互式可视化,使用d3.js和TypeScript编写。虽然这个项目基本上包含了一个非常基本的张量流动操场,但它可以用于不同的手段或者用作不同目的的非常令人印象深刻的教育功能。

    Github地址:https://github.com/tensorflow/playground

    2019年11个值得研究的Javascript机器学习库

     

    8. Compromise

    这个非常受欢迎的库提供“javascript中适度的自然语言处理”。这是非常基本和直接的,甚至可以编译成一个小文件。出于某种原因,其适度的“足够好”的方法使其成为几乎任何需要基本NLP的应用程序的主要候选者。

    Github地址:https://github.com/spencermountain/compromise

    2019年11个值得研究的Javascript机器学习库

     

    9. Neuro.js

    这个漂亮的项目是一个深度学习和强化学习Javascript库框架的浏览器。实现基于完整堆栈神经网络的机器学习框架以及扩展的强化学习支持,一些人认为该项目是convnetjs的继承者。

    Github地址:https://github.com/janhuenermann/neurojs

    2019年11个值得研究的Javascript机器学习库

     

    10. ml.js

    一组存储库,为mljs组织开发的Javascript提供机器学习工具,包括监督和无监督学习,人工神经网络,回归算法和统计,数学等支持库。这是一个简短的演练。

    Github地址:https://github.com/mljs

    2019年11个值得研究的Javascript机器学习库

     

    11. Mind

    Node.js和浏览器的灵活神经网络库,基本上学习如何进行预测,使用矩阵实现来处理训练数据并启用可配置的网络拓扑。您还可以即插即用已经学过的“思想”,这对您的应用程序非常有用。

    Github地址:https://github.com/stevenmiller888/mind

    2019年11个值得研究的Javascript机器学习库

    展开全文
  • 摘要:本篇文章教你如何使用JavaScript在浏览器中完整地定义、训练和部署机器学习算法。 虽然它可能不是机器学习传统选择的开发语言,但是JavaScript正在证明有能力完成这样的工作——即使它目前还不能与主要的机器...

    摘要: 本篇文章教你如何使用JavaScript在浏览器中完整地定义、训练和部署机器学习算法。

    虽然它可能不是机器学习传统选择的开发语言,但是JavaScript正在证明有能力完成这样的工作——即使它目前还不能与主要的机器学习语言Python竞争。在进一步学习之前,让我们做一下机器学习的介绍。

    根据Skyhoshi这个有着超过13年开发人员的实际经验,机器学习赋予计算机根据所提供的数据进行学习的能力,并且识别模式,然后得出结论,而不需要明确的人为干预。

    从传统上来说,JavaScript在机器学习中不常用,有以下两个主要的原因,包括有限的库支持和实现的复杂性。

    虽然如此,JavaScript最近已经颇欢迎了,主要是因为在客户端上有完整的部署机器学习应用的广泛机会。

    在这篇文章中,我将演示一个简单的机器学习辅导项目,它展示了JavaScript也能够为机器学习应用提供动力。

    对于这个相对简单的项目,我将使用Neal.js程序文件,它是一个简便的开源JavaScript库,它为机器学习提供了预处理的神经网络。

    该项目的目的是用一组训练数据来训练一个神经网络,使得它可以预测颜色的对比是亮的还是暗的。

    第一步:安装库

    让我们使用NoDE.js这个文件,并通过NPM包管理器来安装库。为此,你需要在计算机上预先安装No.js文件。

    这里是你可以用在终端上运行的代码。(切记把它安装在你要处理的文件夹上)

     npm install brain.js 

    第二步: 导入库

    使用以下代码在你的文件上导入库:

     const brain = require("brain.js"); 

    第三步:创建一个神经网络

    以下是代码:

     const network = new brain.NeuralNetwork(); 

    第四步:训练数据

    在机器学习之中,训练的数据和收到的结果一样好。更高质量的数据可能比较低质量的数据预测出更好的结果。

    该数据是一组示例,它被提供给算法并“指导”算法要搜索什么东西。

    在这个例子中,由于我们希望这个机器学习算法学会识别光亮和黑暗之间颜色对比的差异,所以我们将给出这些例子来训练学习模型。

    在这之后,该算法将利用所提供的实例来辨别两个组之间的本质特征。

    如果在将来提供了未知的数据,那么这个算法将根据从原始训练模型中识别出来的特征进行分类。

    对于这个项目,我们将使用内置的brain.js程序文件中的train()函数来使用实例数据的数组来训练神经网络。

    每个实例中的训练数据都将有一个输入对象和一个输出对象,它们都应该是一个从0到1的数组。

    因为我们正在使用颜色来进行研究,因此我们要去找到它们的RGB值。由于RGB颜色介于0和255之间,所以我们可以将它们转换为被255相除的0到1之间的值。

    举个例子,如果颜色的RGB值为(158,183,224),我们通过除以255来转换每个值,它将变成(0.62,0.72,0.88)。

    在这之后,我们需要提供RGB值的一些示例数据集,并指定输出将是亮的还是暗的。

    以下是代码:

    network.train([

      {input: {r:0.62,g:0.72,b:0.88}, output:{light: 1}},

      {input: {r:0.1,g:0.84,b:0.72}, output:{light: 1}},

      {input: {r:0.33,g:0.24,b:0.29}, output:{dark: 1}},

      {input: {r:0.74,g:0.78,b:0.86}, output:{light: 1}},

      ]);

    第五步: 查看结果

    在用一些实例数据进行训练算法之后,现在是查看预测结果的时候了。

    我们只需调用Run()函数,并提供一个颜色色调的参数,目的是想知道它是亮的还是暗的。

    以下是代码:

    const result = network.run({r:0.0,g:1,b:0.65});

    console.log(result);

    如果我们在Windows终端上执行以上代码,输出将是这样的:

    0defa2ebd7a17727169818f768db78fcb11897cc 

    正如你所看到的,我们给初学者的机器学习算法预测到颜色对比度是亮色的,准确度为0.97(97%)。

    如果我们希望输出是亮的或者是暗的,那么可以添加下面的代码:

    const result = brain.likely({r:0.0,g:1,b:0.65}, network);

    console.log(result);

    以下终端上的显示结果:

    11b1a89c6b0f8cb7fcfcc34745d51985fb547e5c 

    结论:

    以下是整个项目的代码:

    const brain = require("brain.js");

    const network = new brain.NeuralNetwork();

    network.train([

      {input: {r:0.62,g:0.72,b:0.88}, output:{light: 1}},

      {input: {r:0.1,g:0.84,b:0.72}, output:{light: 1}},

      {input: {r:0.33,g:0.24,b:0.29}, output:{dark: 1}},

      {input: {r:0.74,g:0.78,b:0.86}, output:{light: 1}},

      ]);

    //const result = network.run({r:0.0,g:1,b:0.65});

    const result = brain.likely({r:0.0,g:1,b:0.65}, network);

    console.log(result);

    在这篇文章中,我演示了一个简单的关于JavaScript的机器学习项目。为了提高你的机器学习技能,你当然也需要完成类似的项目。

    原文链接 

    本文为云栖社区原创内容,未经允许不得转载。 

    展开全文
  • 导读:机器学习是目前盛行于世的技术之一,这几年一时风头无两。虽然在机器学习中,Python是人工智能从业者使用最多的编程语言,但是,Java 在项目开发中仍然发挥着不可替代的作用,而且许多流行的机器学习框架本身...

    导读:机器学习是目前盛行于世的技术之一,这几年一时风头无两。虽然在机器学习中,Python是人工智能从业者使用最多的编程语言,但是,Java 在项目开发中仍然发挥着不可替代的作用,而且许多流行的机器学习框架本身就是 Java编写的。Python 的资料到处都是,而 Java 相关的资料就相对少了很多。今天我们翻译了 Fatema Patrawala> 撰写的《六大最常用的 Java 机器学习库一览》。

    MLOSS.org 网站上,列出了 70 多个基于 Java 的开源机器学习项目,可能还有更多未列出的项目,存于大学里的服务器、GitHub 或 Bitbucket 中。我们将在本文中回顾 Java 中的主流机器学习库和平台,它们能够解决的问题类型,支持的算法以及可以使用的数据类型。

    本文节选自 Machine learning in Java,由 Bostjan Kaluza 编写,Packt Publishing Ltd. 出版

    Weka

    Weka 是 Waikato Environment for Knowledge Analysis(Waikato 智能分析环境)的缩写,是新西兰 Waikato 大学开发的机器学习库,也可能是最为有名的 Java 库。Weka 是一个通用的库,能够解决各种机器学习任务,如分类、回归和聚类。它具有丰富的图形用户界面、命令行界面和 Java API。有关 Weka 更多详情,请参阅:http://www.cs.waikato.ac.nz/ml/weka/

    截止到本书写作之时,Weka 总共包含 267 个算法,其中:数据预处理(82),属性选择(33),分类和回归(133),聚类(12),关联规则挖掘(7)。图形界面非常适合用于探索数据,而 Java API 可以让你开发新的机器学习方案并在应用中使用这些算法。
    在这里插入图片描述
    Weka 是在 GNU 通用公共许可证(GNU GPL)下发布的,这意味着你可以复制、分发和修改它,只要你跟踪源文件中的更改并将其保存在 GNU GPL 下。你甚至可以进行商业分发,但前提是你必须公开源代码或获得商业许可证。

    除了几种支持的文件格式外,Weka 还提供了自己的默认数据格式 ARFF,用于通过属性 - 数据对描述数据。它由两部分组成:第一部分包含标题头,它指定所有属性(即特性)及其类型;例如,标称、数字、日期和字符串。第二部分包含数据,其中每行对应于一个实例。标题头中的最后一个属性隐式地被视为目标变量,缺失的数据用问号标记。例如,用 ARFF 文件格式编写的 Bob 实例如下:

        @RELATION person_dataset
        
        @ATTRIBUTE `Name`  STRING
        @ATTRIBUTE `Height`  NUMERIC
        @ATTRIBUTE `Eye color`{blue, brown, green}
        @ATTRIBUTE `Hobbies`  STRING
        
        @DATA
        'Bob', 185.0, blue, 'climbing, sky diving'
        'Anna', 163.0, brown, 'reading'
        'Jane', 168.0, ?, ?
    

    该文件由三个部分组成。第一部分以 @relation 关键字开始,指定数据集名称。下一部分以 @ATTRIBUTE 关键字开始,后面是属性名和类型。可用的类型是 STRING(字符串)、NUMERIC(数字)、DATE(日期)和一组分类值。最后一个属性被隐式假设为我们想要预测的目标变量。最后一部分以 @DATA 关键字开始,每行后面跟着一个实例。实例值用逗号分隔,并且必须遵循与第二部分中的属性相同的顺序。

    Weka 的 Java API 由以下的顶层包组成:

    • weka.associations:这些是关联规则学习的数据结构和算法,包括 Apriori、 predictive apriori、FilteredAssociator、FP-Growth、Generalized Sequential Patterns (GSP)、Hotspot 和 Tertius。

    • weka.classifiers:这些是监督学习算法、评估期和数据结构。该包由以下几个部分组成:

      • weka.classifiers.bayes:它实现了贝叶斯(Bayesian)方法,包括朴素贝叶斯、贝式网络、贝叶斯逻辑回归等。

      • weka.classifiers.evaluation:这些是评价统计、混淆矩阵、ROC 曲线等标称和数值预测的监督评价算法。

      • weka.classifiers.functions:这些是回归算法,包括线性回归、保序回归、高斯过程、支持向量机、多层感知器、表决感知器等。

      • weka.classifiers.lazy:这些是基于实例的算法,比如 k- 最近邻、K*,惰性贝叶斯规则。

      • weka.classifiers.meta:这些是监督学习元算法,包括 AdaBoost、bagging、加性回归、随机委员会(random committee)等。

      • weka.classifiers.mi:这些是多实例算法,如 Citation-KNN、多样性密度、MI AdaBoost 等。

      • weka.classifiers.rules:这些是基于变治法(separate-and-conquer)、Ripper、Part、Prism 的决策表和决策规格。

      • weka.classifiers.trees:这些是各种决策树算法,包括 ID3、C4.5、M5、功能树、逻辑树、随机森林等。

    • weka.clusterers:这些是聚类算法,包括 k-means、Clope、Cobweb、DBSCAN 层次聚类、Farthest 等

    • weka.core:这些是各种实用类、数据表示、配置文件等。

    • weka.datagenerators:这些是用于分类、回归和聚类算法的数据生成器。

    • weka.estimators:这些是用于离散 / 标称域、条件概率估计等的各种数据分布估计。

    • weka.experiment:这是一组类,支持运行实验所需的配置、数据集、模型设置和统计信息。

    • weka.filters:这些是基于属性和基于实例的选择算法,用于监督和非监督数据预处理。

    • weka.gui:这些是实现 Explorer、Experimenter、和 Knowledge Flow 的图形界面。Explorer 允许你调查数据集、算法及其参数,并使用散点图和其他可视化的形式对数据集进行可视化。Experimenter 用于设计批量实验,但它只能用于分类和回归问题。Knowledge Flow 实现了可视化的拖放式用户界面来构建数据流,如:加载数据、应用过滤器、构建分类器和评估。

    用于机器学习的 Java-ML

    Java 机器学习库(Java-ML)是一组机器学习算法的集合,具备用于相同类型的算法的公共接口。它只提供 Java API,因此,它主要面向的是软件工程师和程序员。Java-ML 包含用于数据预处理、特征选择、分类和聚类的算法。此外,它还提供了几个 Weka 桥来直接通过 Java-ML API 访问 Weka 的算法。Java-ML 可从 http://java-ml.sourceforge.net 下载,截至本书完成之际,最近版本发布于 2012 年。
    在这里插入图片描述
    Java-ML 也是一个通用机器学习库。与 Weka 相比,它提供了更为一致的接口和最新算法的实现,在其他包中不存在这些算法,如一系列最先进的相似性度量和特征选择技术等,这些包含动态时间规整、随机森林属性评估等等。Java-ML 也可以在 GNU GPL 许可证下使用。

    Java-ML 支持任何类型的文件,只要它每行包含一个数据样本,并且特征用逗号、分号和制表符分隔。

    Java-ML 库由以下顶层包组成:

    • net.sf.javaml.classification:这些是分类算法,包括朴素贝叶斯、随机森林、Bagging、自组织映射、k- 最近邻等。

    • net.sf.javaml.clustering:这些是聚类算法,包括 kmeans、自组织映射、空间聚类、Cobweb、AQBC 等。

    • net.sf.javaml.core:这些表示实例和数据集。

    • net.sf.javaml.distance:这些是测量实例距离和相似度的算法,如切比雪夫距离(Chebyshev distance)、余弦距离 / 相似度、欧几里得距离(Euclidian distance)、杰卡德距离(Jaccard distance)/ 相似度、马氏距离(Mahalanobis distance)、曼哈顿距离(Manhattan distance)、明氏距离(Minkowski distance)、皮尔逊积矩相关系数(Pearson correlation coefficient)、斯皮尔曼简捷距离(Spearman’s footrule distance)、动态时间规整(dynamic time wrapping,DTW)等。

    • net.sf.javaml.featureselection:这些是用于特征评估、评分、选择和排名的算法,如增益比、ReliefF、Kullback-Liebler 散度、对称不确定性等。

    • net.sf.javaml.filter:这些是通过过滤、删除属性、设置类或属性值等操作实例的方法。

    • net.sf.javaml.matrix:实现内存或基于文件的数组。

    • net.sf.javaml.sampling:实现选择数据集子集的采样算法。net.sf.javaml.tools:这些是关于数据集、实例操作、序列化、Weka API 接口等的使用方法。

    • net.sf.javaml.utils:这些是算法的实用方法,如统计、数学方法、列联表等表等。

    Apache Mahout

    Apache Mahout 项目旨在构建可扩展的机器学习库。它是在可扩展分布式体系结构(如 Hadoop)上构建的,实用 MapReduce 范例,这是一种实用服务器集群处理和生成具有并行分布式算法的大型数据及的方法。
    在这里插入图片描述
    Mahout 提供了控制台界面和 Java API,可用于聚类、分类和写作过滤的可扩展算法。它可以解决这三个业务问题:项目推荐,如向喜欢某部电影的人推荐其他可能喜欢的电影;聚类,如将文本文档分组与主题相关的文档组中归档;分类,如学习将哪个主题分配给未标记的文档。

    Mahout 是在商业化的 Apache 许可证下分发的,这意味着只要你保留 Apache 许可证并将其显示在程序的版权声明中,你就可以使用它。

    Mahout 提供了以下库:
    org.apache.mahout.cf.taste:这些是基于用户和基于项目的协同过滤算法,及基于 ALS 的矩阵分解算法。

    • org.apache.mahout.classifier:这些是内存和分布式实现,包括逻辑回归、朴素贝叶斯、随机森林、隐马尔科夫模型(hidden Markov models,HMM)和多层感知器。

    • org.apache.mahout.clustering:这些是聚类算法,例如 Canopy 聚类、k-means、模糊 k-means、流式 K-means 和谱聚类。

    • org.apache.mahout.common:这些是算法的实用方法,包括距离、MapReduce 操作、迭代器等。

    • org.apache.mahout.driver:实现了通用驱动程序来运行其他类的主要方法。

    • org.apache.mahout.ep:这是使用记录步骤突变的进化优化。

    • org.apache.mahout.math:这些是 Hadoop 中的各种数据额实用方法和实现。

    • org.apache.mahout.vectorizer:这些是用于数据表示、操作和 MapReduce 任务的类。

    Apache Spark

    Apache Spark(或简称 Spark)是在 Hadoop 上构建大规模数据处理的平台,但与 Mahout 不同的是,它与 MapReduce 范式无关。相反,它使用内存缓存提取工作数据集,对其进行处理并重复查询。据报道,Spark 直接处理磁盘存储数据的速度是 Mahout 实现的十倍。可从 https://spark.apache.org 下载。
    在这里插入图片描述
    在 Spark 之上构建了许多模块,例如用于图形处理的 GraphX、用于处理实时数据流的 Spark Streaming 和用于机器学习库的 MLlib,这些模块具有分类、回归、协同过滤、聚类、降维和优化。

    Spark 的 MLlib 可以使用基于 Hadoop 的数据源,例如 Hadoop 分布式文件系统(HDFS)或 HBase,以及本地文件。支持的数据类型包括以下几种:

    • 局部向量存储在一台机器上。稠密向量表示为双类型值数组,如 (2.0,0.0,10.,0.0);而稀疏向量由向量的大小、索引数组和值数组表示,如 [4, (0, 2), (2.0, 1.0)]。

    • 标记点用于监督学习算法,由局部向量组成,用双类型的类值标记。标签可以是类索引、二进制结果或多个类索引的列表(多类分类)。例如,标记的稠密向量表示为 [1.0, (2.0, 0.0, 1.0, 0.0)]。

    • 局部矩阵在单台机器上存储稠密矩阵。它由矩阵维数和以列主序排列的单个双数组定义。

    • 分布式矩阵对存储在 Spark 的弹性分布式数据集(Resilient Distributed Dataset,RDD)中的数据进行操作,RDD 表示可以并行操作的元素集合。有三种表示:行矩阵,其中每一行都是可以存储在一台机器上的局部向量,但行索引没有意义;索引行矩阵,类似于行矩阵,但行索引是有意义的,即可以识别行并执行行连接;坐标矩阵,当行不能存储在一台机器上,且矩阵非常稀疏时才使用。

    Spark 的 MLlib API 库提供了各种学习算法和实用工具的接口,如下所示:

    • org.apache.spark.mllib.classification:这些是二元和多类分类算法,包括线性 SVM、逻辑回归、决策树和朴素贝叶斯。

    • org.apache.spark.mllib.clustering:这些是 k-means 聚类。

    • org.apache.spark.mllib.linalg:这些是数据表示,包括稠密向量、稀疏向量和矩阵。

    • org.apache.spark.mllib.optimization:这是 MLlib 中作为低级基元的各种优化算法,包括梯度下降、随机梯度下降、分布式 SGD 的更新方案和有限内存 BFGS。

    • org.apache.spark.mllib.recommendation:这些是基于模型的协同过滤,通过交替最小二乘矩阵分解来实现。

    • org.apache.spark.mllib.regression:这些是回归学习算法,如线性最小二乘、决策树、Lasso 和 Ridge 回归。

    • org.apache.spark.mllib.stat:这些是稀疏或稠密向量格式的样本的统计函数,用于计算均值、方差、最小值、最大值、计数和非零计数。org.apache.spark.mllib.tree:实现了分类和回归决策树的算法。

    • org.apache.spark.mllib.util:这些是用于加载、保存、预处理、生成和验证数据的方法的集合。

    Deeplearning4j

    DeepLearning4j(或称 DL4J),是一个用 Java 编写的深度学习库。它具有分布式和单机深度学习框架,包括并支持各种神经网络结构,如前馈神经网络、RBM(Restricted Boltzmann Machine,受限玻尔兹曼机)、卷积神经网络、深度信念网络、自动编码器等。DL4J 可以解决不同的问题,比如识别面孔、声音、垃圾邮件和电子商务欺诈。

    Deeplearning4j 也是在 Apache 2.0 许可下分发的,可从 http://deeplearning4j.org 下载。该库由以下组成:

    • org.deeplearning4j.base:这些是加载类。

    • org.deeplearning4j.berkeley:这些是数学使用方法。

    • org.deeplearning4j.clustering:k-means 的聚类实现。

    • org.deeplearning4j.datasets:这是数据集的操作,包括导入、创建、迭代等。

    • org.deeplearning4j.distributions:这是用于分发的实用方法。

    • org.deeplearning4j.eval:这些是评估类,包括混淆矩阵。

    • org.deeplearning4j.exceptions:实现异常处理程序。

    • org.deeplearning4j.models:这些是监督学习算法,包括深度信念网络、堆叠式自动编码器、堆叠去噪式自动编码器和 RBM。

    • org.deeplearning4j.nn:这些是基于神经网络的组件和算法的实现,例如神经网络、多层网络、卷积多层网络等。

    • org.deeplearning4j.optimize:这些是神经网络优化算法,包括反向传播、多层优化、输出层优化等。

    • org.deeplearning4j.plot:这些是用于呈现数据的各种方法。

    • org.deeplearning4j.rng:这是一个随机数据生成器。

    • org.deeplearning4j.util:这些是帮助和实用方法。

    MALLET

    机器学习语言工作包(Machine Learning for Language Toolkit,MALLET),是一个包含自然语言处理算法和实用程序的大型库。它可以用于各种任务,如文档分类、分档聚类、信息提取和主题建模。MALLET 提供了命令行界面和 Java API,适用于多种算法,如朴素贝叶斯、HMM(Hidden Markov Model,隐马尔可夫模型)、隐含狄利克主题模型(Latent Dirichlet topic model)、逻辑回归和条件随机域(conditional random fields)。
    在这里插入图片描述
    MALLET 可以在通用公共许可证 1.0 下使用,这意味着你甚至可以在商业应用程序中使用它。可以从 http://mallet.cs.umass.edu 下载。MALLET 实例由名称、标签、数据和源表示。但是,有两种方法可以将数据导入到 MALLET 格式中,如下所示:

    • Instance per file:每个文件(即文档)对应一个实例,MALLET 接受输入的目录名。

    • Instance per line:每行对应一个实例,假设使用以下格式:instance_name 标签令牌。数据将是一个特征向量,由作为标记出现的不同单词和它们出现次数组成。

    该库由以下包组成:

    • cc.mallet.classify:这些是用于训练和分类实例的算法,包括 AdaBoost、Bagging、C4.5、以及其他决策树模型、多元逻辑回归、朴素贝叶斯和 Winnow2。

    • cc.mallet.cluster:这些是无监督聚类算法,包括贪心凝聚( greedy agglomerative)、爬山算法(hill climbing)、k-best 和 k-means 聚类。

    • cc.mallet.extract:实现分词器(tokenizers)、文档提取器、文档查看器和清理器等。

    • cc.mallet.fst: 实现了序列模型,包括条件随机域、HMM、最大熵马尔科夫模型(maximum entropy Markov models),以及相应的算法和评估器。

    • cc.mallet.grmm:实现了如推理算法、学习和测试的图形模型和因子图。例如环状信念传播(loopy belief propagation)、吉布斯采样(Gibbs sampling)等。

    • cc.mallet.optimize:这些是用于寻找函数最大值的优化算法,例如梯度上升、有限内存 BFGS、随机元上升(stochastic meta ascent)等。

    • cc.mallet.pipe:这些方法是将数据处理为 MALLET 实例中的管道。cc.mallet.topics:这些是主题建模算法,例如隐含狄利克分布(Latent Dirichlet allocation)、四级弹球分布(four-level pachinko allocation)、分层 PAM、DMRT 等。

    • cc.mallet.types:实现了基本数据类型,如数据集、特征向量、实例和标签。

    • cc.mallet.util:这些是各种实用工具功能,如命令行处理、搜索、数学、测试等。

    如果你想利用关键的 Java 机器学习库进行设计、构建和部署你自己的机器学习应用,请查阅 Packt Publishing 出版社出版的《Java 机器学习》(Machine Learning in Java)一书。

    转载自:https://hub.packtpub.com/most-commonly-used-java-machine-learning-libraries/#

    下一步阅读:

    5 JavaScript machine learning libraries you need to know

    A non programmer’s guide to learning Machine learning

    Why use JavaScript for machine learning?

    展开全文
  • 机器学习十大开源工具 机器学习是未来。但机器会灭绝人类吗? 这应该是一个牵强附会的想法。 作为机器学习开发人员,您一定希望成功实现目标。这就是用于机器学习的开源工具的用武之地。 机器学习开源社区是...
  • BAT机器学习面试1000题系列 整理:July、元超、立娜、德伟、贾茹、王剑、AntZ、孟莹等众人。本系列大部分题目来源于公开网络,取之分享,用之分享,且在撰写答案过程中若引用他人解析则必注明原作者及来源链接...
  • 随着时间的推移,机器学习库变得更快也更易于使用...最近一段时间,Web 生态系统发展迅速,虽然 JavaScript 和 Node.js 在性能上仍然不及 Python 和 Java,但它们也已经强大到足以处理许多机器学习的问题。Web 开发语言
  • TensorFlow.js 是一个 JavaScript 库,用于在浏览器和 Node.js 训练和部署机器学习模型。 TensorFlow.js 可以为你提供高性能的、易于使用的机器学习构建模块,允许你在浏览器上训练模型,或以推断模式运行预训练的...
  • 推荐 | 图解机器学习

    2018-01-18 12:17:32
    微信公众号关键字全网搜索最新排名【机器学习算法】:排名第一【机器学习】:排名第一【Python】:排名第三【算法】:排名第四源 | ynaughty 每当提到机器学习,大家总是被其中的各种各样的算法和方法搞晕,觉得...
  •   本篇主要是让大家熟悉机器学习实际项目中的全流程,并伴随案例讲解,通过让大家动手了解实际机器学习项目的大体流程,以及面对一些常见情况的处理方法 编程环境: Anaconda3:juputer notebook Python3 Pycharm...
  • 摘要:随着机器学习越来越受到开发者关注,出现了很多机器学习的开源项目,在本文列举的11个机器学习开源项目中,无论你是Java爱好者还是Python狂人,在这里你都可以找到自己想要的机器学习开源项目。 垃圾邮件过滤...
  • 随着机器学习越来越受到开发者关注,出现了很多机器学习的开源项目,在本文列举的11个机器学习开源项目中,无论你是Java爱好者还是Python狂人,在这里你都可以找到自己想要的机器学习开源项目。  垃圾邮件过滤、...
  • 在这篇文章中,主要介绍如何将一个机器学习的模型嵌入到web系统中,这篇文章的主要内容包括: 1、利用flask构建一个简单的web 2、将机器学习模型嵌入到web系统中 3、根据用户的反馈来更新模型 主要包括三个页面,...
  • 本文介绍了适用于移动端的 10 个机器学习框架,包括针对计算机的机器学习框架和针对手机端的优化性能的框架。 本文介绍了适用于移动端的 10 个机器学习框架,包括针对计算机的机器学习框架和针对手机端的优化性能的...
  • (例如,来自德国的AndreyBu在机器学习方面拥有超过5年的经验,他一直在利用各种开源框架来构建引人入胜的机器学习项目。) 尽管Python编程语言支持大多数机器学习框架,但JavaScript并没有被抛在后面。 ...
  • 图解机器学习

    2017-09-28 17:03:18
    警告:多图杀猫! 每当提到机器学习,大家总是被其中的各种各样的算法和方法搞晕,觉得无从下手。确实,机器学习的各种套路确实不少,但是如果掌握了...其实机器学习的基本算法都很简单,下面我们就利用二维数据和交互
  • 随着近几年AI的火热,越来越多的出现有关各个机器学习框架的对比文章,且随着 Python 逐渐成为机器学习社区最受欢迎的语言,支持 Python 的深度学习框架的性能也在持续的被关注。 本文是我根据诸多文献给予此,将...
  •  之前本博客整理过数千道微软等公司的面试题,侧重数据结构、算法、海量数据处理,详见:微软面试100题系列,今17年,近期和团队整理BAT机器学习面试1000题系列,侧重机器学习、深度学习。我们将通过这个系列索引绝...
  • Airbnb信任和安全小组通过构建机器学习模型进行欺诈预测,本文介绍了其设计思想。假想模型是预测某些虚拟人物是否为“反面人物”,基本步骤:构建模型预期,构建训练集和测试集,特征学习,模型性能评估。其中特征...
1 2 3 4 5 ... 20
收藏数 30,284
精华内容 12,113
关键字:

利用js 机器学习