【JavaScript】Principal component analysis (PCA) using JavaScript

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

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

立即领取

感谢您参与论坛问题回答

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

+2 论坛币

ml-pca

Principal component analysis (PCA)

Installation

$ npm install ml-pca

DocumentationLicense

MIT

本帖隐藏的内容

pca-master.zip (1.16 MB)

2017-4-16 04:15:45 上传

扫码加我 拉你入群

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

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

分享0 收藏0 回帖

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

复制代码