Cleaned up repo

Author: dcrescim

.eslintrc.json

@@ -1,10 +1,17 @@
 {
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
   "env": {
     "browser": true,
     "es6": true,
     "mocha": true
   },
-  "extends": "eslint:recommended",
   "globals": {
     "Atomics": "readonly",
     "SharedArrayBuffer": "readonly"

.prettierrc

@@ -1,5 +1,5 @@
 {
-  "trailingComma": "es5",
+  "trailingComma": "none",
   "tabWidth": 2,
   "semi": false,
   "singleQuote": true,

package.json

@@ -16,12 +16,13 @@
     "simple-statistics": "^7.7.0"
   },
   "scripts": {
-    "test": "nyc mocha --require ts-node/register 'test/**/*.test.ts'",
-    "test:clean": "yarn build:clean && yarn test",
+    "test": "nyc mocha --require ts-node/register '**/*.test.ts'",
+    "test:clean": "yarn build:clean && yarn test && yarn lint && yarn prettier",
     "dev": "nodemon",
     "build": "tsc",
     "build:clean": "rimraf ./build && tsc",
-    "lint": "eslint ./src",
+    "prettier": "prettier --check './src'",
+    "lint": "eslint ./src/**/*.ts",
     "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls",
     "coverage": "nyc report --reporter=text-lcov | coveralls && nyc report --reporter=lcov",
     "patch": "npm version patch"
@@ -58,12 +59,15 @@
     "@types/mocha": "^8.2.2",
     "@types/node": "^16.9.6",
     "@types/table": "^6.3.2",
+    "@typescript-eslint/eslint-plugin": "^5.1.0",
+    "@typescript-eslint/parser": "^5.1.0",
     "chai": "^4.2.0",
     "coveralls": "^3.1.0",
-    "eslint": "^7.1.0",
+    "eslint": "^8.0.1",
     "mocha": "^7.2.0",
     "nodemon": "^2.0.7",
     "nyc": "^15.1.0",
+    "prettier": "^2.4.1",
     "rimraf": "^3.0.2",
     "ts-node": "^10.0.0",
     "typescript": "^4.4.2",

src/estimators/elastic.net.ts

@@ -34,22 +34,22 @@ export class ElasticNet extends SGD {
       modelCompileArgs: {
         optimizer: train.adam(0.1),
         loss: losses.meanSquaredError,
-        metrics: ['mse'],
+        metrics: ['mse']
       },
       modelFitArgs: {
         batchSize: 32,
         epochs: 1000,
         verbose: 0,
-        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 50 })],
+        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 50 })]
       },
       denseLayerArgs: {
         units: 1,
         kernelRegularizer: regularizers.l1l2({
           l1: params.alpha * params.l1Ratio,
-          l2: 0.5 * params.alpha * (1 - params.l1Ratio),
+          l2: 0.5 * params.alpha * (1 - params.l1Ratio)
         }),
-        useBias: Boolean(params.fitIntercept),
-      },
+        useBias: Boolean(params.fitIntercept)
+      }
     })
   }
 }

src/estimators/lasso.regression.ts

@@ -33,19 +33,19 @@ export class LassoRegression extends SGD {
       modelCompileArgs: {
         optimizer: train.adam(0.1),
         loss: losses.meanSquaredError,
-        metrics: ['mse'],
+        metrics: ['mse']
       },
       modelFitArgs: {
         batchSize: 32,
         epochs: 1000,
         verbose: 0,
-        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 50 })],
+        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 50 })]
       },
       denseLayerArgs: {
         units: 1,
         kernelRegularizer: regularizers.l1({ l1: params.alpha }),
-        useBias: Boolean(params.fitIntercept),
-      },
+        useBias: Boolean(params.fitIntercept)
+      }
     })
   }
 }

test/estimators/linear.model.test.ts renamed to src/estimators/linear.model.test.ts

@@ -3,10 +3,10 @@ import * as tf from '@tensorflow/tfjs-core'
 import { assert } from 'chai'
 import { LinearRegression } from '../../dist'
 import 'mocha'
-import { tensorEqual } from '../utils.test'
-import { tensor, Tensor1D, tensor2d, Tensor2D } from '@tensorflow/tfjs-core'
+import { tensorEqual } from '../utils'
+import { Tensor1D, Tensor2D } from '@tensorflow/tfjs-core'
 
-function roughlyEqual(a: number, b: number, tol: number = 0.1) {
+function roughlyEqual(a: number, b: number, tol = 0.1) {
   return Math.abs(a - b) < tol
 }
 
@@ -25,7 +25,7 @@ describe('LinearRegression', function () {
       [[1], [2]],
       [
         [2, 1],
-        [4, 2],
+        [4, 2]
       ]
     )
 

src/estimators/linear.model.ts

@@ -47,18 +47,18 @@ export class LinearRegression extends SGD {
       modelCompileArgs: {
         optimizer: train.adam(0.1),
         loss: losses.meanSquaredError,
-        metrics: ['mse'],
+        metrics: ['mse']
       },
       modelFitArgs: {
         batchSize: 32,
         epochs: 1000,
         verbose: 0,
-        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 30 })],
+        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 30 })]
       },
       denseLayerArgs: {
         units: 1,
-        useBias: Boolean(params.fitIntercept),
-      },
+        useBias: Boolean(params.fitIntercept)
+      }
     })
   }
 }

src/estimators/logistic.regression.ts

@@ -0,0 +1,84 @@
+// /**
+// *  @license
+// * Copyright 2021, JsData. All rights reserved.
+// *
+// * This source code is licensed under the MIT license found in the
+// * LICENSE file in the root directory of this source tree.
+
+// * Unless required by applicable law or agreed to in writing, software
+// * distributed under the License is distributed on an "AS IS" BASIS,
+// * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// * See the License for the specific language governing permissions and
+// * limitations under the License.
+// * ==========================================================================
+// */
+
+// import '@tensorflow/tfjs-node'
+// import { losses, train } from '@tensorflow/tfjs-core'
+// import { callbacks } from '@tensorflow/tfjs-layers'
+// import { SGD } from './sgd.linear'
+// import {
+//   initializers,
+//   regularizers,
+//   Tensor1D,
+//   Tensor2D,
+// } from '@tensorflow/tfjs-node'
+// import { tensor1dConv, tensor2dConv } from 'utils'
+
+// // First pass at a LinearRegression implementation using gradient descent
+// // Trying to mimic the API of scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html
+
+// export interface LogisticRegressionParams {
+//   penalty: 'l1' | 'l2' | 'none'
+//   C: number
+//   fitIntercept: boolean
+// }
+
+// export class LogisticRegression extends SGD {
+//   constructor(params: LogisticRegressionParams) {
+//     // Assume Binary classification
+//     // If we call fit, and it isn't binary then update args
+//     super({
+//       modelCompileArgs: {
+//         optimizer: train.adam(0.1),
+//         loss: losses.sigmoidCrossEntropy,
+//         metrics: ['accuracy'],
+//       },
+//       modelFitArgs: {
+//         batchSize: 32,
+//         epochs: 1000,
+//         verbose: 0,
+//         callbacks: [
+//           callbacks.earlyStopping({ monitor: 'loss', patience: 50 }),
+//         ],
+//       },
+//       denseLayerArgs: {
+//         units: 1,
+//         useBias: Boolean(params.fitIntercept),
+//         kernelInitializer: initializers.zeros(),
+//         biasInitializer: initializers.zeros(),
+//         kernelRegularizer:
+//           params.penalty === 'l2'
+//             ? regularizers.l2({ l2: params.C })
+//             : params.penalty === 'l1'
+//             ? regularizers.l1({ l1: params.C })
+//             : undefined,
+//       },
+//     })
+//   }
+
+//   // Placeholder for eventual code that will determine if we need to
+//   // do one-hot-encoding
+//   async fit(
+//     X: Tensor2D | number[][],
+//     y: Tensor1D | number[]
+//   ): Promise<LogisticRegression> {
+//     let XTwoD = tensor2dConv(X)
+//     let yOneD = tensor1dConv(y)
+//     if (this.model.layers.length === 0) {
+//       this.initializeModel(XTwoD.shape[1])
+//     }
+//     await this.model.fit(XTwoD, yOneD, { ...this.modelFitArgs })
+//     return this
+//   }
+// }

src/estimators/ridge.regression.ts

@@ -34,19 +34,19 @@ export class RidgeRegression extends SGD {
       modelCompileArgs: {
         optimizer: train.adam(0.1),
         loss: losses.meanSquaredError,
-        metrics: ['mse'],
+        metrics: ['mse']
       },
       modelFitArgs: {
         batchSize: 32,
         epochs: 1000,
         verbose: 0,
-        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 50 })],
+        callbacks: [callbacks.earlyStopping({ monitor: 'mse', patience: 50 })]
       },
       denseLayerArgs: {
         units: 1,
         kernelRegularizer: regularizers.l2({ l2: params.alpha }),
-        useBias: Boolean(params.fitIntercept),
-      },
+        useBias: Boolean(params.fitIntercept)
+      }
     })
   }
 }

src/estimators/sgd.linear.ts

@@ -19,21 +19,22 @@ import {
   Tensor1D,
   Tensor2D,
   tensor1d,
-  tensor2d,
+  tensor2d
 } from '@tensorflow/tfjs-core'
 import {
   layers,
   sequential,
   Sequential,
   ModelFitArgs,
-  ModelCompileArgs,
+  ModelCompileArgs
 } from '@tensorflow/tfjs-layers'
 import { DenseLayerArgs } from '@tensorflow/tfjs-layers/dist/layers/core'
 import {
   convertToNumericTensor1D_2D,
-  convertToNumericTensor2D,
+  convertToNumericTensor2D
 } from '../utils'
 import { Scikit2D, ScikitVecOrMatrix } from '../types'
+import { PredictorMixin } from '../mixins'
 /**
  * SGD is a thin Wrapper around Tensorflow's model api with a single dense layer.
  * With this base class and different error functions / regularizers we can
@@ -71,12 +72,12 @@ export interface SGDParams {
   modelFitArgs: ModelFitArgs
 
   /**
-   * The arguments for a single dense layer in tensorflow. This also defaults to 
+   * The arguments for a single dense layer in tensorflow. This also defaults to
    * different settings based on the regressor / classifier. An example dense layer
    * might look like.
    *  const model = sequential()
       model.add(
-        layers.dense({ inputShape: [100], 
+        layers.dense({ inputShape: [100],
         units: 1,
         useBias: true,
       })
@@ -85,13 +86,14 @@ export interface SGDParams {
   denseLayerArgs: DenseLayerArgs
 }
 
-export class SGD {
+export class SGD extends PredictorMixin {
   model: Sequential
   modelFitArgs: ModelFitArgs
   modelCompileArgs: ModelCompileArgs
   denseLayerArgs: DenseLayerArgs
 
   constructor(params: SGDParams) {
+    super()
     this.model = sequential()
     this.modelFitArgs = params.modelFitArgs
     this.modelCompileArgs = params.modelCompileArgs
@@ -187,7 +189,7 @@ export class SGD {
     let myIntercept = tensor1d([params.intercept_], 'float32')
     this.initializeModel(myCoef.shape, myIntercept.shape, [
       myCoef,
-      myIntercept,
+      myIntercept
     ])
     return this
   }
@@ -203,7 +205,7 @@ export class SGD {
    *
    * lr = new LinearRegression()
    * lr.getParams()
-   * // => 
+   * // =>
     {
       modelCompileArgs: {
         optimizer: train.adam(0.1),
@@ -227,7 +229,7 @@ export class SGD {
     return {
       modelFitArgs: this.modelFitArgs,
       modelCompileArgs: this.modelCompileArgs,
-      denseLayerArgs: this.denseLayerArgs,
+      denseLayerArgs: this.denseLayerArgs
     }
   }
 
@@ -303,7 +305,7 @@ export class SGD {
    * await lr.fit(X, [1,2,3]);
    * lr.coef_
    * // => tensor1d([[ 1.2, 3.3, 1.1, 0.2 ]])
-   * 
+   *
    * await lr.fit(X, [ [1,2], [3,4], [5,6] ]);
    * lr.coef_
    * // => tensor2d([ [1.2, 3.3], [3.4, 5.6], [4.5, 6.7] ])

test/impute/simple.imputer.test.ts renamed to src/impute/simple.imputer.test.ts

@@ -1,6 +1,5 @@
 import { assert } from 'chai'
 import { SimpleImputer } from '../../dist'
-import { Series, DataFrame } from 'danfojs-node'
 
 describe('SimpleImputer', function () {
   it('Imputes with "constant" strategy. In this strategy, we give the fill value', function () {