Self-organizing Map using JavaScript

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

ml-som

self-organizing map (SOM) / Kohonen network

Installation

$ npm install ml-som

Methodsnew SOM(x, y, [options])

Creates a new SOM instance with x * y dimensions.

Arguments

• x - Dimension of the x axis
• y - Dimension of the y axis
• options - Object with options for the algorithm
  

Options

• fields - Either a number (size of input vectors) or a map of field descriptions (to convert them to vectors)
• iterations - Number of iterations over the training set for the training phase (default: 10). The total number of training steps will be iterations * trainingSet.length
• learningRate - Multiplication coefficient for the learning algorithm (default: 0.1)
• method - Iteration method of the learning algorithm (default: random)
  • random - Pick an object of the training set randomly
  • traverse - Go sequentially through the training set
    
• randomizer - Function that must give numbers between 0 and 1 (default: Math.random)
• distance - Function that computes the distance between two vectors of the same length (default: squared Euclidean distance)
• gridType - Shape of the grid (default: rect)
  • rect - Rectangular grid
  • hexa - Hexagonal grid
    
• torus - Boolean indicating if the grid should be considered a torus for the selection of the neighbors (default: true)
  

Example

var SOM = require('ml-som');var options = {  fields: {    r: [0, 255],    g: [0, 255],    b: [0, 255]  }};var som = new SOM(20, 20, options);
train(trainingSet)

Train the SOM with the provided trainingSet.

Arguments

• trainingSet - Array of training elements. If the fields was a number, each array element must be a normalized vector. If it was an object, each array element must be an object with at least the described properties, within the described ranges
  

Example

var trainingSet = [  { r: 0, g: 0, b: 0 },  { r: 255, g: 0, b: 0 },  { r: 0, g: 255, b: 0 },  { r: 0, g: 0, b: 255 },  { r: 255, g: 255, b: 255 }];som.train(trainingSet);
getConvertedNodes()

Returns a 2D array containing the nodes of the grid, in the structure described by the fields option.

setTraining(trainingSet)

Set the training set for use with the next method

trainOne()

Executes the next training iteration and returns true. Returns false if the training is over. Useful to draw the grid or compute some things after each learning step.

Example

som.setTraining(trainingSet);while(som.trainOne()) {  var nodes = som.getConvertedNodes();  // do something with the nodes}
predict([data], [computePosition])

Returns for each data point the coordinates of the corresponding best matching unit (BMU) on the grid

Arguments

• data - Data point or array of data points (default: training set).
• computePosition - True if you want to compute the position of the point in the cell, using the direct neighbors (default: false). This option is currently only implemented for rectangular grids.
  

Example

// create and train the somvar result1 = som.predict({ r: 45, g: 209, b: 100 });// result1 = [ 2, 26 ]var result2 = som.predict([{ r: 45, g: 209, b: 100 }, { r: 155, g: 22, b: 12 }], true);// result2 = [ [ 2, 26, [ 0.236, 0.694 ] ], [ 33, 12, [ 0.354, 0.152 ] ] ]
getFit([dataset])

Returns an array of fit values which are the square root of the distance between the input vector and its corresponding BMU.

Arguments

• dataset - Array of vectors to for which to calculate fit values. Defaults to the training set.
  

getQuantizationError()

Returns the mean of the fit values for the training set. This number can be used to compare several runs of the same SOM.

getUMatrix()

Returns a 2D array representing the grid. Each value is the mean of the distances between the corresponding node and its direct neighbors. Currently only available for square nodes

export()

Exports the model to a JSON object that can be written to disk and reloaded

SOM.load(model, [distanceFunction])

Returns a new SOM instance based on the model. If the model was created with a custom distance function, the distanceargument should be this function.

Arguments

• model - JSON object generated with som.export()
• distanceFunction - Optionally provide the distance function used to create the model.
  

License

MIT

本帖隐藏的内容

som-master.zip (10.19 KB)

2016-6-27 00:11:56 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏2 回帖

关键词：Javascript Organizing script scrip Using default training convert Object number

1. 'use strict';
   
2. 
   
3. var NodeSquare = require('./node-square');
   
4. 
   
5. function NodeHexagonal(x, y, weights, som) {
   
6. 
   
7.     NodeSquare.call(this, x, y, weights, som);
   
8. 
   
9.     this.hX = x - Math.floor(y / 2);
   
10.     this.z = 0 - this.hX - y;
    
11. 
    
12. }
    
13. 
    
14. NodeHexagonal.prototype = new NodeSquare();
    
15. NodeHexagonal.prototype.constructor = NodeHexagonal;
    
16. 
    
17. NodeHexagonal.prototype.getDistance = function getDistanceHexagonal(otherNode) {
    
18.     return Math.max(Math.abs(this.hX - otherNode.hX), Math.abs(this.y - otherNode.y), Math.abs(this.z - otherNode.z));
    
19. };
    
20. 
    
21. NodeHexagonal.prototype.getDistanceTorus = function getDistanceTorus(otherNode) {
    
22.     var distX = Math.abs(this.hX - otherNode.hX),
    
23.         distY = Math.abs(this.y - otherNode.y),
    
24.         distZ = Math.abs(this.z - otherNode.z);
    
25.     return Math.max(Math.min(distX, this.som.gridDim.x - distX), Math.min(distY, this.som.gridDim.y - distY), Math.min(distZ, this.som.gridDim.z - distZ));
    
26. };
    
27. 
    
28. NodeHexagonal.prototype.getPosition = function getPosition() {
    
29.     throw new Error('Unimplemented : cannot get position of the points for hexagonal grid');
    
30. };
    
31. 
    
32. module.exports = NodeHexagonal;

复制代码

1. 'use strict';
   
2. 
   
3. function NodeSquare(x, y, weights, som) {
   
4.     this.x = x;
   
5.     this.y = y;
   
6.     this.weights = weights;
   
7.     this.som = som;
   
8.     this.neighbors = {};
   
9. }
   
10. 
    
11. NodeSquare.prototype.adjustWeights = function adjustWeights(target, learningRate, influence) {
    
12.     for (var i = 0, ii = this.weights.length; i < ii; i++) {
    
13.         this.weights[i] += learningRate * influence * (target[i] - this.weights[i]);
    
14.     }
    
15. };
    
16. 
    
17. NodeSquare.prototype.getDistance = function getDistance(otherNode) {
    
18.     return Math.max(Math.abs(this.x - otherNode.x), Math.abs(this.y - otherNode.y));
    
19. };
    
20. 
    
21. NodeSquare.prototype.getDistanceTorus = function getDistanceTorus(otherNode) {
    
22.     var distX = Math.abs(this.x - otherNode.x),
    
23.         distY = Math.abs(this.y - otherNode.y);
    
24.     return Math.max(Math.min(distX, this.som.gridDim.x - distX), Math.min(distY, this.som.gridDim.y - distY));
    
25. };
    
26. 
    
27. NodeSquare.prototype.getNeighbors = function getNeighbors(xy) {
    
28.     if (!this.neighbors[xy]) {
    
29.         this.neighbors[xy] = new Array(2);
    
30. 
    
31.         // left or bottom neighbor
    
32.         var v;
    
33.         if (this[xy] > 0) {
    
34.             v = this[xy] - 1;
    
35.         } else if (this.som.torus) {
    
36.             v = this.som.gridDim[xy] - 1;
    
37.         }
    
38.         if (typeof v !== 'undefined') {
    
39.             var x, y;
    
40.             if (xy === 'x') {
    
41.                 x = v;
    
42.                 y = this.y;
    
43.             } else {
    
44.                 x = this.x;
    
45.                 y = v;
    
46.             }
    
47.             this.neighbors[xy][0] = this.som.nodes[x][y];
    
48.         }
    
49. 
    
50.         // top or right neighbor
    
51.         var w;
    
52.         if (this[xy] < (this.som.gridDim[xy] - 1)) {
    
53.             w = this[xy] + 1;
    
54.         } else if (this.som.torus) {
    
55.             w = 0;
    
56.         }
    
57.         if (typeof w !== 'undefined') {
    
58.             if (xy === 'x') {
    
59.                 x = w;
    
60.                 y = this.y;
    
61.             } else {
    
62.                 x = this.x;
    
63.                 y = w;
    
64.             }
    
65.             this.neighbors[xy][1] = this.som.nodes[x][y];
    
66.         }
    
67.     }
    
68.     return this.neighbors[xy];
    
69. };
    
70. 
    
71. NodeSquare.prototype.getPos = function getPos(xy, element) {
    
72.     var neighbors = this.getNeighbors(xy),
    
73.         distance = this.som.distance,
    
74.         bestNeighbor,
    
75.         direction;
    
76.     if(neighbors[0]) {
    
77.         if (neighbors[1]) {
    
78.             var dist1 = distance(element, neighbors[0].weights),
    
79.                 dist2 = distance(element, neighbors[1].weights);
    
80.             if(dist1 < dist2) {
    
81.                 bestNeighbor = neighbors[0];
    
82.                 direction = -1;
    
83.             } else {
    
84.                 bestNeighbor = neighbors[1];
    
85.                 direction = 1;
    
86.             }
    
87.         } else {
    
88.             bestNeighbor = neighbors[0];
    
89.             direction = -1;
    
90.         }
    
91.     } else {
    
92.         bestNeighbor = neighbors[1];
    
93.         direction = 1;
    
94.     }
    
95.     var simA = 1 - distance(element, this.weights),
    
96.         simB = 1 - distance(element, bestNeighbor.weights);
    
97.     var factor = ((simA - simB) / (2 - simA - simB));
    
98.     return 0.5 + 0.5 * factor * direction;
    
99. };
    
100. 
     
101. NodeSquare.prototype.getPosition = function getPosition(element) {
     
102.     return [
     
103.         this.getPos('x', element),
     
104.         this.getPos('y', element)
     
105.     ];
     
106. };
     
107. 
     
108. module.exports = NodeSquare;

复制代码