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

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]];

现在，您可以使用K均值算法对数据进行聚类。

var result = ml.kmeans.cluster({
    data : data,
    k : 4,
    epochs: 100,
    init_using_data : true, // this is default
    distance : {type : "pearson"}

    /*
        distance : {type : 'euclidean'} // this is default
        distance : {type : 'pearson'}

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

        distance : function(x1,x2) { // Euclidean Distance Function
            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("clusters : ", result.clusters);
// clusters :  [ [ 5, 6, 7, 8, 9, 10 ], [], [], [ 0, 1, 2, 3, 4 ] ]

console.log("means : ", result.means);
/* means :  [ [ 0.16666666666666666, 0, 0.5, 0, 0.16666666666666666, 0.5, 0.8333333333333334, 0.8333333333333334, 0.8333333333333334, 0.6666666666666666, 0.5, 0.8333333333333334, 1, 0.3333333333333333 ],
              [ 1, 0.25, 1, 0.25, 0.75, 1, 1, 0.5, 0.5, 0.25, 0, 0, 1, 0 ],
              [ 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0 ],
              [ 1, 0.6, 1, 0.6, 1, 1, 1, 0.2, 0.2, 0, 0, 0, 1, 0.2 ] ]
                                                                            */

k值和epochs分别是分类数和训练次数。如果init_use_data字段为真，则从数据中随机抽取K-均值的初始值。init_use_data的默认值为true

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

方法返回JSON，其中包含两个字段，即集群和方法。簇是由属于同一簇的数据索引组成的数组的数组。均值是k簇的质心数组。

非负矩阵分解

这个特性非常简单。这是一个非负矩阵分解的示例代码。

var matrix = [[22,28],
              [49,64]];

var result = ml.nmf.factorize({
    matrix : matrix,
    features : 3,
    epochs : 100
});

console.log("First Matrix : ",result[0]);
/*
First Matrix :  [ [ 0.31669834888695564, 0.34857863366710945, 0.30093035193924644 ],
                  [ 1.0207704459010163, 0.8332243876037893, 0.12448796813440478 ] ]
                                                                                          */

console.log("Second Matrix : ",result[1]);
/*
Second Matrix :  [ [ 22.346573917816208, 5.674344603157743 ],
                   [ 29.04976516996404, 68.74672486952171 ],
                   [ 15.939733080271976, 7.4412733531764115 ] ]

方法分解中的矩阵是我们要分解的矩阵。

矩阵特征和训练时分别是特征的数量和训练阶段。

方法对由分解矩阵组成的返回数组进行分解。

该库中的非负矩阵分解采用乘法更新规则作为训练算法.

梯度下降

这个特征只是梯度下降算法的一个简单实现。

首先，定义自己的目标函数，以最小化。这个函数只有一个参数，即输入向量。这是一个例子。

var costf = function(vec) {
    var cost = 0;
    for(var i =0; i<14;i++) { // This example is using 15-dimensional input vector.
        cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
    }
    cost += (3.*vec[14]/vec[0]);
    return cost; // our goal is finding a vector which makes the cost value minimum.
};

要通过梯度优化此成本，您应该在输入向量中设置每个变量元素的域。

var domain = [];
for(var i=0;i<15;i++)
    domain.push([1,70]);
    // domain[idx][0] : minimum of vec[idx], domain[idx][1] : maximum of vec[idx].

现在，您可以使用下面的梯度算法代码优化成本函数。

var vec = ml.optimize.hillclimb({
    domain : domain,
    costf : costf
});

这种梯度方法返回向量，使成本函数最小化。

console.log("vec : ",vec);
console.log("cost : ",costf(vec));