Add support for cluster prediction and update example

kgryte · kgryte · commit a8c647d7c596 · 2018-07-11T10:25:15.000+01:00
diff --git a/lib/node_modules/@stdlib/ml/incr/kmeans/examples/index.js b/lib/node_modules/@stdlib/ml/incr/kmeans/examples/index.js
@@ -24,6 +24,7 @@ var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
 var normal = require( '@stdlib/random/base/normal' ).factory;
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var Float64Array = require( '@stdlib/array/float64' );
+var Int8Array = require( '@stdlib/array/int8' );
 var incrkmeans = require( './../lib' );
 
 var clusters;
@@ -37,6 +38,9 @@ var N;
 var k;
 var c;
 var v;
+var m;
+var p;
+var r;
 var X;
 var Y;
 var x;
@@ -77,10 +81,18 @@ for ( i = 0; i < k; i++ ) {
 	randn.set( i, 1, normal( clusters.get( i, 2 ), clusters.get( i, 3 ) ) );
 }
 
-// Create a 2-d vector for storing simulated data:
+// Create a vector for storing simulated data:
 ctor = ndarray( 'float64', 1 );
 v = ctor( new Float64Array( 2 ), [ 2 ], [ 1 ], 0, 'row-major' );
 
+// Wrap the vector in a matrix for generating cluster predictions:
+ctor = ndarray( 'float64', 2 );
+m = ctor( v.data, [ 1, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+// Create a vector for storing cluster predictions:
+ctor = ndarray( 'int8', 1 );
+p = ctor( new Int8Array( 1 ), [ 1 ], [ 1 ], 0, 'row-major' );
+
 // Simulate data points and incrementally perform k-means clustering...
 totals = [ 0, 0, 0, 0, 0 ];
 X = [];
@@ -99,6 +111,11 @@ for ( i = 0; i < N; i++ ) {
 	v.set( 1, y );
 	Y.push( y );
 
+	// Generate a cluster prediction:
+	r = acc.predict( p, m );
+	if ( r ) {
+		console.log( 'Data point: (%d, %d). Prediction: %d.', x.toFixed( 3 ), y.toFixed( 3 ), r.get( 0 )+1 );
+	}
 	// Update the accumulator:
 	results = acc( v );
 }
diff --git a/lib/node_modules/@stdlib/ml/incr/kmeans/lib/main.js b/lib/node_modules/@stdlib/ml/incr/kmeans/lib/main.js
@@ -233,24 +233,69 @@ function incrkmeans( K, ndims, options ) {
 	* Computes data point distances to centroids and returns centroid assignment predictions.
 	*
 	* @private
+	* @param {ndarray} [out] - output vector for storing centroid assignment predictions
 	* @param {ndarray} X - matrix containing data points (`n x d`, where `n` is the number of data points and `d` is the number of dimensions)
+	* @throws {TypeError} output argument must be a vector
 	* @throws {TypeError} must provide a matrix
+	* @throws {Error} vector length must match number of data points
 	* @throws {Error} number of matrix columns must match centroid dimensions
-	* @returns {ndarray} vector containing centroid (index) predictions
+	* @returns {(ndarray|null)} vector containing centroid (index) predictions or null
 	*/
-	function predict( X ) {
-		var out;
-		if ( !isMatrixLike( X ) ) {
-			throw new TypeError( 'invalid argument. Must provide a 2-dimensional ndarray. Value: `' + X + '`.' );
+	function predict( out, X ) {
+		var xbuf;
+		var cbuf;
+		var npts;
+		var sx1;
+		var sx2;
+		var sc;
+		var ox;
+		var x;
+		var o;
+		var c;
+		var i;
+		if ( arguments.length > 1 ) {
+			if ( !isVectorLike( out ) ) {
+				throw new TypeError( 'invalid argument. Output argument must be a 1-dimensional ndarray. Value: `' + out + '`.' );
+			}
+			o = out;
+			x = X;
+		} else {
+			x = out;
+		}
+		if ( !isMatrixLike( x ) ) {
+			throw new TypeError( 'invalid argument. Must provide a 2-dimensional ndarray. Value: `' + x + '`.' );
 		}
-		if ( X.shape[ 1 ] !== ndims ) {
-			throw new Error( 'invalid input argument. Number of matrix columns must match centroid dimensions. Expected: ' + ndims + '. Actual: ' + X.shape[ 1 ] + '.' );
+		if ( x.shape[ 1 ] !== ndims ) {
+			throw new Error( 'invalid input argument. Number of matrix columns must match centroid dimensions. Expected: ' + ndims + '. Actual: ' + x.shape[ 1 ] + '.' );
 		}
-		out = createVector( out.shape[ 0 ], false ); // high-level
+		if ( o && o.length !== x.shape[ 0 ] ) {
+			throw new Error( 'invalid input argument. Output vector length must match the number of data points. Expected: ' + x.shape[ 0 ] + '. Actual: ' + o.length + '.' );
+		} else {
+			o = createVector( x.shape[ 0 ], false ); // high-level
+		}
+		if ( init ) {
+			return null;
+		}
+		cbuf = centroids.data;
+		sc = centroids.strides[ 0 ];
 
-		// TODO: (prediction) compute distances and assign data points to centroids
+		xbuf = x.data;
+		npts = x.shape[ 0 ];
+		sx1 = x.strides[ 0 ];
+		sx2 = x.strides[ 1 ];
+		ox = x.offset;
 
-		return out;
+		// For each data point, find the closest centroid...
+		for ( i = 0; i < npts; i++ ) {
+			c = closestCentroid( dist, k, ndims, cbuf, sc, 0, xbuf, sx2, ox ); // Magic number `0` for offset as we know that the matrix view begins at the first buffer element
+
+			// Update the output vector:
+			o.set( i, c );
+
+			// Compute the data point buffer index offset to point to the next data point:
+			ox += sx1;
+		}
+		return o;
 	}
 }
 
