机器学习API文档(演示) (一)监督学习

最新推荐文章于 2022-10-14 19:20:44 发布

置顶 thinkKoa

最新推荐文章于 2022-10-14 19:20:44 发布

阅读量701

点赞数 1

分类专栏： node.js

node.js 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

在阅读之前..。请原谅我英语不好，因为我不是说英语的人。

开始吧！

关于用于node.js的机器学习库。还可以在浏览器中使用此库。(演示) 这是国家预防机制和集散地。您可以在这里找到本文档中使用的所有示例代码。

安装对于Node.js，首先从NPM安装模块。

npm install machine_learning

var ml = require('machine_learning');

若要在浏览器中使用此库，请包含Machine_learning.min.js文件。

<script src="/js/machine_learning.min.js"></script>

然后你可以像这样使用模块。

var result = ml.nmf.factorize({ // variable 'ml' is the module.
    matrix : matrix,
    features : 3,
    epochs : 100
});

监督学习

逻辑回归

首先，准备分类数据集。下面是一个例子。

var x = [[1,1,1,0,0,0],
         [1,0,1,0,0,0],
         [1,1,1,0,0,0],
         [0,0,1,1,1,0],
         [0,0,1,1,0,0],
         [0,0,1,1,1,0]];

var y = [[1, 0],
         [1, 0],
         [1, 0],
         [0, 1],
         [0, 1],
         [0, 1]];

变量y的每一行都应该是二进制标签向量。在这种情况下，数据集有两个标签。

然后，使用该数据集创建新的逻辑回归类。

var classifier = new ml.LogisticRegression({
    'input' : x,
    'label' : y,
    'n_in' : 6,
    'n_out' : 2
});

如您所见，输入和标签字段是我们要分类的数据集。

字段n_in和n_out分别是输入向量和标号向量的维数。

classifier.train({
    'lr' : 0.6,
    'epochs' : 2000
});

字段LR和EIRCHS分别是学习速率和训练时间。

最后，可以使用此分类器对新数据进行分类。

var test_x = [[1, 1, 0, 0, 0, 0],
              [0, 0, 0, 1, 1, 0],
              [1, 1, 1, 1, 1, 0]];

console.log("Result : ",classifier.predict(test_x));
/* Result :  [ [ 0.9913047066877619, 0.008695293312237968 ],
               [ 0.008695293312237968, 0.9913047066877619 ],
               [ 0.5000000000000001, 0.49999999999999994  ] ] */

在对分类器进行训练时，模块会在控制台中记录一些培训信息。可以使用以下代码控制日志记录级别。

classifier.set('log level',1);0：没有，1：信息，2：警告。

实际上，我建议您将日志级别字段设置为0。

您可以看到如何通过使用getRestruction信息熵方法对分类器进行良好的训练。

console.log("Entropy : "+classifier.getReconstructionCrossEntropy());

该方法计算了标号向量y的重建交叉熵(RCE)。 RCE由下列方程计算。

$RCE = - p log(p_{recon}) - (1-p)log(1-p_{recon})$

训练后，可以得到输出层的Logistic回归分类器的权重矩阵W和偏差向量b。

console.log("W : " + classifier.W);
console.log("b : " + classifier.b);

另外，在训练分类器之前，还可以用一定的值初始化权重矩阵W和偏差向量b。(在调用分类器的训练方法之前。默认值为零矩阵/向量。)

classifier.W = initial_W;
classifier.b = initial_b;

classifier.train({...});

多层感知器(演示)

首先，准备分类数据集。下面是一个例子

var x = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
         [0.5, 0.3,  0.5, 0.,  0.,  0.],
         [0.4, 0.5, 0.5, 0.,  0.,  0.],
         [0.,  0.,  0.5, 0.3, 0.5, 0.],
         [0.,  0.,  0.5, 0.4, 0.5, 0.],
         [0.,  0.,  0.5, 0.5, 0.5, 0.]];

var y = [[1, 0],
         [1, 0],
         [1, 0],
         [0, 1],
         [0, 1],
         [0, 1]];

然后，使用这个数据集创建新的多层感知器.

var mlp = new ml.MLP({
    'input' : x,
    'label' : y,
    'n_ins' : 6,
    'n_outs' : 2,
    'hidden_layer_sizes' : [4,4,5]
});

如您所见，输入和标签字段是我们要分类的数据集。字段n_ins和n_out分别是输入向量和标号向量的维数。字段隐藏层的大小是每个隐藏层中隐藏单元的数量。例如， [4，4，5]表示具有结构“输入”-“4单位隐藏层”-“4单位隐藏层”-“5单位隐藏层”-输出的MLP。

现在是训练分类器的时候了。

mlp.train({
    'lr' : 0.6,
    'epochs' : 20000
});

字段LR和EIRCHS分别是学习速率和训练时间。

最后，可以使用此分类器对新数据进行分类。

var test_x = [[0.5, 0.5, 0., 0., 0., 0.],
              [0., 0., 0., 0.5, 0.5, 0.],
              [0.5, 0.5, 0.5, 0.5, 0.5, 0.]];

console.log("Result : ",mlp.predict(test_x));
/* Result :  [ [ 0.9938587852428853, 0.006129518061725184 ],
               [ 0.006093644091104495, 0.9939203795412749 ],
               [ 0.5107729901219014, 0.4892207646122191 ] ] */

在对分类器进行训练时，模块会在控制台中记录一些培训信息。可以使用以下代码控制日志记录级别。

classifier.set('log level',1); // 0 : nothing, 1 : info, 2 : warning.

实际上，我建议您将日志级别字段设置为0。

您可以看到如何通过使用getRestruction信息熵方法对分类器进行良好的训练。

console.log("Entropy : "+mlp.getReconstructionCrossEntropy());

该方法计算了标号向量y的重建交叉熵(RCE)。 RCE由下列方程计算。

$RCE = - p log(p_{recon}) - (1-p)log(1-p_{recon})$

经过训练，你可以得到你的多层感知器的权重矩阵W和每个隐藏层和输出层的偏差b。

for(var i=0; i < mlp.sigmoidLayers.length; i++) {
    if(i !== mlp.sigmoidLayers.length-1) {
        console.log((i+1)+"th hidden layer W : ", mlp.sigmoidLayers[i].W);
        console.log((i+1)+"th hidden layer b : ", mlp.sigmoidLayers[i].b);
    } else {
        console.log("output layer W : " + mlp.sigmoidLayers[i].W);
        console.log("output layer b : " + mlp.sigmoidLayers[i].b);
    }
}

另外，当创建多层感知器实例时，可以用一定的值初始化权重矩阵W和偏差向量b。(当调用分类器的构造函数方法时。缺省值分别为随机矩阵和零向量，分别表示权重W和偏置向量b。

var mlp = new ml.MLP({
    'input' : x,
    'label' : y,
    'n_ins' : 6,
    'n_outs' : 2,
    'hidden_layer_sizes' : [4,4,5],
    'w_array' : [initial_W1, initial_W2, initial_W3, initial_W4],
    'b_array' : [initial_b1, initial_b2, initial_b3, initial_b3] // undefined field will be initialized with default value.
});

您可能已经看到代码，类似于mlp.sigmoidLayers[i]

这个变量是 i 是4层隐藏层实例，隐藏层的默认激活函数是Sigmoid函数，但您可以通过以下代码将该函数更改为自定义函数。

mlp.sigmoidLayers[i].activation = function(x) {
    return (1. / (1 + Math.exp(-x))); // this is sigmoid function
};

隐藏层实例的一些功能。

console.log("LinearOutput (Wx + b) : ",mlp.sigmoidLayers[i].linearOutput(x))
console.log("output (activation(Wx + b)) : ",mlp.sigmoidLayers[i].output(x))
// default 'activation' function is sigmoid
console.log("backpropagation (x * transpose(W)) : ",mlp.sigmoidLayers[i].backPropagate(x))

支持向量机(演示)

首先，准备分类数据集。下面是一个例子。

var x = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
         [0.5, 0.3,  0.5, 0.,  0.,  0.01],
         [0.4, 0.8, 0.5, 0.,  0.1,  0.2],
         [1.4, 0.5, 0.5, 0.,  0.,  0.],
         [1.5, 0.3,  0.5, 0.,  0.,  0.],
         [0., 0.9, 1.5, 0.,  0.,  0.],
         [0., 0.7, 1.5, 0.,  0.,  0.],
         [0.5, 0.1,  0.9, 0.,  -1.8,  0.],
         [0.8, 0.8, 0.5, 0.,  0.,  0.],
         [0.,  0.9,  0.5, 0.3, 0.5, 0.2],
         [0.,  0.,  0.5, 0.4, 0.5, 0.],
         [0.,  0.,  0.5, 0.5, 0.5, 0.],
         [0.3, 0.6, 0.7, 1.7,  1.3, -0.7],
         [0.,  0.,  0.5, 0.3, 0.5, 0.2],
         [0.,  0.,  0.5, 0.4, 0.5, 0.1],
         [0.,  0.,  0.5, 0.5, 0.5, 0.01],
         [0.2, 0.01, 0.5, 0.,  0.,  0.9],
         [0.,  0.,  0.5, 0.3, 0.5, -2.3],
         [0.,  0.,  0.5, 0.4, 0.5, 4],
         [0.,  0.,  0.5, 0.5, 0.5, -2]];

var y = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1];
// -1, 1 表示有2个分类

然后，使用此数据集创建新的支持向量机。

var svm = new ml.SVM({
    x : x,
    y : y
});

如您所见，x和y字段是我们要分类的数据集。

现在是训练分类器的时候了。

svm.train({
    C : 1.1, // 默认情况：1.0. C在支持向量机中.
    tol : 1e-5, // 默认情况：1E-4。高公差->高精度
    max_passes : 20, // 默认值：20. 较高的max_PASS->更高的精度
    alpha_tol : 1e-5, // 默认情况：1E-5。较高的α公差->高精度
    kernel : { type: "polynomial", c: 1, d: 5}

    /*
       kernel : {type : "gaussian", sigma : 1.0} // this is default.
       kernel : {type : "linear"} // x*y
       kernel : {type : "polynomial", c : 1, d : 8} // (x*y + c)^d

       或者你可以使用你自己的定义。

       kernel : function(vecx,vecy) {
                    return dot(vecx,vecy);
                }                                     */
});

您可以通过设置变量C来控制最小化错误率的重要性。通常，C值越高，错误率越小的重要性就越高。还可以通过将变量设置为l、max_PASS、alpha_TOL来控制SVM的精度。

您可以使用4种类型的内核。高斯，线性，多项式和你的自定义函数。您可以在示例代码中找到每个内核的使用情况(参见注释)。

最后，可以使用此分类器对新数据进行分类。

console.log("Predict : ",svm.predict([1.3,  1.7,  0.5, 0.5, 1.5, 0.4]));
// Predict : -1

该库中的支持向量机采用序列最小优化(SMO)作为训练算法。

K近邻(演示)

首先，准备分类数据集。下面是一个例子。

var data = [[1,0,1,0,1,1,1,0,0,0,0,0,1,0],
            [1,1,1,1,1,1,1,0,0,0,0,0,1,0],
            [1,1,1,0,1,1,1,0,1,0,0,0,1,0],
            [1,0,1,1,1,1,1,1,0,0,0,0,1,0],
            [1,1,1,1,1,1,1,0,0,0,0,0,1,1],
            [0,0,1,0,0,1,0,0,1,0,1,1,1,0],
            [0,0,0,0,0,0,1,1,1,0,1,1,1,0],
            [0,0,0,0,0,1,1,1,0,1,0,1,1,0],
            [0,0,1,0,1,0,1,1,1,1,0,1,1,1],
            [0,0,0,0,0,0,1,1,1,1,1,1,1,1],
            [1,0,1,0,0,1,1,1,1,1,0,0,1,0]];

var result = [23,12,23,23,45,70,123,73,146,158,64];

然后，使用该数据集创建新的K-近邻模型.

var knn = new ml.KNN({
    data : data,
    result : result
});

如您所见，数据和结果字段是我们要使用的数据集。

K近邻和前面提到的模型之间的区别是K近邻不需要训练步骤。因此，您可以在创建K-最近的邻居实例之后对新数据进行分类。

var prediction = knn.predict({
    x : [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
    k : 3,
    weightf : {type : 'gaussian', sigma : 10.0},
    distance : {type : 'euclidean'}

    /*
        weightf : {type: "none"} // 默认为none
        weightf : {type : "gaussian", sigma : 10.0}

        或者你可以用自己的权重算法。

        weightf : function(x) {
            return Math.exp(-1.*x*x/(2*10.0*10.0)); // 高斯内核函数
        }

        distance : {type : 'euclidean'} // 默认

        或者你可以用你自己的距离算法

        distance : function(x1,x2) { // 欧氏距离函数
            var distance = 0;
            for(var i=0 ; i < x1.length; i++) {
                var dx = x1[i] - x2[i];
                distance += dx * dx;
            }
            return Math.sqrt(distance);
        };
                                                     */
});

console.log("Prediction : ",prediction); // Prediction : 142.37964352973836

该库中的K最近邻模型支持其加权版本（内核）。有三种类型的加权函数（内核），你可以使用。没有（没有权重），高斯函数和你的自定义函数。您可以在示例代码中找到每个加权函数的用法(参见注释)。

您还可以自定义此模型使用的距离函数。有两种类型的距离函数，您可以使用。欧几里德和你的定制功能。您可以在示例代码(查看注释)中找到每个距离函数的用法。

决策树（示例）

参考资料：Toby Segaran编写的“编程集体智能”。

首先，准备分类数据集。下面是一个例子。 (与编程集体智能中的示例相同)

var data = [['slashdot','USA','yes',18],
            ['google','France','yes',23],
            ['digg','USA','yes',24],
            ['kiwitobes','France','yes',23],
            ['google','UK','no',21],
            ['(direct)','New Zealand','no',12],
            ['(direct)','UK','no',21],
            ['google','USA','no',24],
            ['slashdot','France','yes',19],
            ['digg','USA','no',18,],
            ['google','UK','no',18,],
            ['kiwitobes','UK','no',19],
            ['digg','New Zealand','yes',12],
            ['slashdot','UK','no',21],
            ['google','UK','yes',18],
            ['kiwitobes','France','yes',19]];

var result = ['None','Premium','Basic','Basic','Premium','None','Basic','Premium','None','None','None','None','Basic','None','Basic','Basic'];

然后可以使用此数据集创建新的决策树

var dt = new ml.DecisionTree({
    data : data,
    result : result
});

现在，是时候构建这个决策树的基本结构了。

dt.build();

该方法通过寻找最优准则自动生成决策树，从而使决策树的信息熵最小化。(分类和回归树(CART)算法)

可以使用打印方法将此决策树打印到控制台。

dt.print();

现在，您可以使用此决策树对新数据进行分类。

console.log("Classify : ", dt.classify(['(direct)','USA','yes',5]));

建议修剪决策树以避免过度拟合。

dt.prune(1.0); // 1.0 : mingain.

该库中的决策树采用简单的剪枝算法，当合并的熵损失小于最小增益值时，将决策树的两个分支合并。可以使用以下方法访问决策树的根节点。

var tree = dt.getTree();

基本上，这个树变量是内部决策节点类的实例。对于这个决策节点实例，有几种方法。

console.log("True Branch of this node : ", tree.tb);
// 返回的值也是一个决策节点实例。

console.log("False Branch of this node : ", tree.fb);
// 返回的值也是一个决策节点实例。

console.log("此节点的条件(对于数字值) : ","'If input_vector["+tree.col+"] >== "+tree.value+", classify as True'");

console.log("此节点的条件(对于NaN值) : ","'If input_vector["+tree.col+"] === "+tree.value+", classify as True'");

对于决策树中的每个叶节点(树的末端)，您可以获得被分类到该节点的数据。

console.log("分类为叶节点的数据 : ",leaf_node.results);

如果节点不是叶节点，则节点的结果字段未定义。

还可以使用以下代码打印整个决策树的子树。

dt.getTree().tb.tb.print()
dt.getTree().print() // this code is same as dt.print()

thinkKoa

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习API文档(演示) (一)监督学习

在阅读之前..。请原谅我英语不好，因为我不是说英语的人。开始吧！关于用于node.js的机器学习库。还可以在浏览器中使用此库。(演示) 这是国家预防机制和集散地。您可以在这里找到本文档中使用的所有示例代码。安装对于Node.js，首先从NPM安装模块。npm install machine_learningvar ml = require('machin
复制链接

扫一扫