Principal Component Analysis using JavaScript

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

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

立即领取

感谢您参与论坛问题回答

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

+2 论坛币

1. ml-pca
   
2. NPM version  build status  David deps  npm download
   
3. 
   
4. Principal component analysis (PCA)
   
5. 
   
6. Installation
   
7. 
   
8. $ npm install ml-pca
   
9. 
   
10. Methods
    
11. 
    
12. new PCA(dataset, options)
    
13. 
    
14. Arguments
    
15. 
    
16. dataset - Data to get the PCA. It must be a two-dimensional array with observations as rows and variables as columns.
    
17. Options
    
18. 
    
19. center - Center the dataset (default: true)
    
20. scale - Standardize the dataset, i.e. divide by the standard deviation after centering (default: false)
    
21. predict(dataset)
    
22. 
    
23. Project the dataset in the PCA space
    
24. 
    
25. Arguments
    
26. 
    
27. dataset - A Matrix of the dataset to project.
    
28. getExplainedVariance()
    
29. 
    
30. Returns the percentage of variance explained by each component.
    
31. 
    
32. getCumulativeVariance()
    
33. 
    
34. Returns the cumulative explained variance.
    
35. 
    
36. getStandardDeviations()
    
37. 
    
38. Returns the standard deviations of each component.
    
39. 
    
40. getEigenvectors()
    
41. 
    
42. Get the eigenvectors of the covariance matrix.
    
43. 
    
44. getEigenvalues()
    
45. 
    
46. Get the eigenvalues on the diagonal.
    
47. 
    
48. getLoadings()
    
49. 
    
50. Get the loadings matrix (each row is a component and each column is a variable)
    
51. 
    
52. License

复制代码

本帖隐藏的内容

pca-master.zip (7.29 KB)

2016-6-27 00:01:16 上传

扫码加我 拉你入群

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

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

分享0 收藏1 回帖

关键词：Javascript Component PRINCIPAL Analysis Analysi default standard version status false

1. 'use strict';
   
2. 
   
3. const Matrix = require('ml-matrix');
   
4. const EVD = Matrix.DC.EVD;
   
5. const SVD = Matrix.DC.SVD;
   
6. const Stat = require('ml-stat').matrix;
   
7. const mean = Stat.mean;
   
8. const stdev = Stat.standardDeviation;
   
9. 
   
10. const defaultOptions = {
    
11.     isCovarianceMatrix: false,
    
12.     center: true,
    
13.     scale: false
    
14. };
    
15. 
    
16. class PCA {
    
17.     /**
    
18.      * Creates new PCA (Principal Component Analysis) from the dataset
    
19.      * @param {Matrix} dataset
    
20.      * @param {Object} options - options for the PCA algorithm
    
21.      * @param {boolean} reload - for load purposes
    
22.      * @param {Object} model - for load purposes
    
23.      * @constructor
    
24.      * */
    
25.     constructor(dataset, options, reload, model) {
    
26.         if (reload) {
    
27.             this.center = model.center;
    
28.             this.scale = model.scale;
    
29.             this.means = model.means;
    
30.             this.stdevs = model.stdevs;
    
31.             this.U = Matrix.checkMatrix(model.U);
    
32.             this.S = model.S;
    
33.             return;
    
34.         }
    
35. 
    
36.         options = Object.assign({}, defaultOptions, options);
    
37. 
    
38.         this.center = false;
    
39.         this.scale = false;
    
40.         this.means = null;
    
41.         this.stdevs = null;
    
42. 
    
43.         if (options.isCovarianceMatrix) { // user provided a covariance matrix instead of dataset
    
44.             this._computeFromCovarianceMatrix(dataset);
    
45.             return;
    
46.         }
    
47. 
    
48.         var useCovarianceMatrix;
    
49.         if (typeof options.useCovarianceMatrix === 'boolean') {
    
50.             useCovarianceMatrix = options.useCovarianceMatrix;
    
51.         } else {
    
52.             useCovarianceMatrix = dataset.length > dataset[0].length;
    
53.         }
    
54.         
    
55.         if (useCovarianceMatrix) { // user provided a dataset but wants us to compute and use the covariance matrix
    
56.             dataset = this._adjust(dataset, options);
    
57.             const covarianceMatrix = dataset.transpose().mmul(dataset).div(dataset.rows - 1);
    
58.             this._computeFromCovarianceMatrix(covarianceMatrix);
    
59.         } else {
    
60.             dataset = this._adjust(dataset, options);
    
61.             var svd = new SVD(dataset, {
    
62.                 computeLeftSingularVectors: false,
    
63.                 computeRightSingularVectors: true,
    
64.                 autoTranspose: true
    
65.             });
    
66. 
    
67.             this.U = svd.rightSingularVectors;
    
68. 
    
69.             const singularValues = svd.diagonal;
    
70.             const eigenvalues = new Array(singularValues.length);
    
71.             for (var i = 0; i < singularValues.length; i++) {
    
72.                 eigenvalues[i] = singularValues[i] * singularValues[i] / (dataset.length - 1);
    
73.             }
    
74.             this.S = eigenvalues;
    
75.         }
    
76.     }
    
77. 
    
78.     /**
    
79.      * Load a PCA model from JSON
    
80.      * @oaram {Object} model
    
81.      * @return {PCA}
    
82.      */
    
83.     static load(model) {
    
84.         if (model.name !== 'PCA')
    
85.             throw new RangeError('Invalid model: ' + model.name);
    
86.         return new PCA(null, null, true, model);
    
87.     }
    
88. 
    
89.     /**
    
90.      * Exports the current model to an Object
    
91.      * @return {Object} model
    
92.      */
    
93.     toJSON() {
    
94.         return {
    
95.             name: 'PCA',
    
96.             center: this.center,
    
97.             scale: this.scale,
    
98.             means: this.means,
    
99.             stdevs: this.stdevs,
    
100.             U: this.U,
     
101.             S: this.S,
     
102.         };
     
103.     }
     
104. 
     
105.     /**
     
106.      * Projects the dataset into new space of k dimensions.
     
107.      * @param {Matrix} dataset
     
108.      * @return {Matrix} dataset projected in the PCA space.
     
109.      */
     
110.     predict(dataset) {
     
111.         dataset = new Matrix(dataset);
     
112. 
     
113.         if (this.center) {
     
114.             dataset.subRowVector(this.means);
     
115.             if (this.scale) {
     
116.                 dataset.divRowVector(this.stdevs);
     
117.             }
     
118.         }
     
119.         
     
120.         return dataset.mmul(this.U);
     
121.     }
     
122. 
     
123.     /**
     
124.      * Returns the proportion of variance for each component.
     
125.      * @return {[number]}
     
126.      */
     
127.     getExplainedVariance() {
     
128.         var sum = 0;
     
129.         for (var i = 0; i < this.S.length; i++) {
     
130.             sum += this.S[i];
     
131.         }
     
132.         return this.S.map(value => value / sum);
     
133.     }
     
134. 
     
135.     /**
     
136.      * Returns the cumulative proportion of variance.
     
137.      * @return {[number]}
     
138.      */
     
139.     getCumulativeVariance() {
     
140.         var explained = this.getExplainedVariance();
     
141.         for (var i = 1; i < explained.length; i++) {
     
142.             explained[i] += explained[i - 1];
     
143.         }
     
144.         return explained;
     
145.     }
     
146. 
     
147.     /**
     
148.      * Returns the Eigenvectors of the covariance matrix.
     
149.      * @returns {Matrix}
     
150.      */
     
151.     getEigenvectors() {
     
152.         return this.U;
     
153.     }
     
154. 
     
155.     /**
     
156.      * Returns the Eigenvalues (on the diagonal).
     
157.      * @returns {[number]}
     
158.      */
     
159.     getEigenvalues() {
     
160.         return this.S;
     
161.     }
     
162. 
     
163.     /**
     
164.      * Returns the standard deviations of the principal components
     
165.      * @returns {[number]}
     
166.      */
     
167.     getStandardDeviations() {
     
168.         return this.S.map(x => Math.sqrt(x));
     
169.     }
     
170. 
     
171.     /**
     
172.      * Returns the loadings matrix
     
173.      * @return {Matrix}
     
174.      */
     
175.     getLoadings() {
     
176.         return this.U.transpose();
     
177.     }
     
178. 
     
179.     _adjust(dataset, options) {
     
180.         this.center = !!options.center;
     
181.         this.scale = !!options.scale;
     
182. 
     
183.         dataset = new Matrix(dataset);
     
184. 
     
185.         if (this.center) {
     
186.             const means = mean(dataset);
     
187.             const stdevs = this.scale ? stdev(dataset, means, true) : null;
     
188.             this.means = means;
     
189.             dataset.subRowVector(means);
     
190.             if (this.scale) {
     
191.                 for (var i = 0; i < stdevs.length; i++) {
     
192.                     if (stdevs[i] === 0) {
     
193.                         throw new RangeError('Cannot scale the dataset (standard deviation is zero at index ' + i);
     
194.                     }
     
195.                 }
     
196.                 this.stdevs = stdevs;
     
197.                 dataset.divRowVector(stdevs);
     
198.             }
     
199.         }
     
200. 
     
201.         return dataset;
     
202.     }
     
203. 
     
204.     _computeFromCovarianceMatrix(dataset) {
     
205.         const evd = new EVD(dataset, {assumeSymmetric: true});
     
206.         this.U = evd.eigenvectorMatrix;
     
207.         for (var i = 0; i < this.U.length; i++) {
     
208.             this.U[i].reverse();
     
209.         }
     
210.         this.S = evd.realEigenvalues.reverse();
     
211.     }
     
212. }
     
213. 
     
214. module.exports = PCA;

复制代码

多谢楼主分享