javascriptdata · dcrescim · May 8, 2022 · May 4, 2022 · May 8, 2022 · May 8, 2022
diff --git a/docs/convert.js b/docs/convert.js
@@ -189,7 +189,6 @@ function getTypeName(val, bigObj) {
 }
 
 function generateProperties(jsonClass, bigObj) {
-  // console.log(jsonClass.children)
   let interface = getInterfaceForClass(jsonClass, bigObj)
   let allConstructorArgs = []
   if (interface && interface.children) {

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -51,6 +51,7 @@
   "dependencies": {
     "@tensorflow/tfjs": "^3.16.0",
     "@tensorflow/tfjs-node": "^3.16.0",
+    "base64-arraybuffer": "^1.0.2",
     "lodash": "^4.17.21",
     "mathjs": "^10.0.0",
     "simple-statistics": "^7.7.0"

diff --git a/src/cluster/KMeans.test.ts b/src/cluster/KMeans.test.ts
@@ -1,5 +1,4 @@
-import { KMeans } from './KMeans'
-
+import { fromJSON, KMeans } from '../index'
 // Next steps: Improve on kmeans cluster testing
 describe('KMeans', () => {
   const X = [
@@ -38,7 +37,7 @@ describe('KMeans', () => {
     )
   })
 
-  it('should save kmeans model', () => {
+  it('should save kmeans model', async () => {
     const expectedResult = {
       name: 'KMeans',
       nClusters: 2,
@@ -48,7 +47,7 @@ describe('KMeans', () => {
       randomState: 0,
       nInit: 10,
       clusterCenters: {
-        type: 'Tensor',
+        name: 'Tensor',
         value: [
           [2.5, 1],
           [2.5, 4]
@@ -57,20 +56,20 @@ describe('KMeans', () => {
     }
     const kmean = new KMeans({ nClusters: 2, randomState: 0 })
     kmean.fit(X)
-    const ksave = kmean.toJson() as string
+    const ksave = await kmean.toObject()
 
-    expect(expectedResult).toEqual(JSON.parse(ksave))
+    expect(expectedResult).toEqual(ksave)
   })
 
-  it('should load serialized kmeans model', () => {
+  it('should load serialized kmeans model', async () => {
     const centroids = [
       [2.5, 1],
       [2.5, 4]
     ]
     const kmean = new KMeans({ nClusters: 2, randomState: 0 })
     kmean.fit(X)
-    const ksave = kmean.toJson() as string
-    const ksaveModel = new KMeans().fromJson(ksave)
+    const ksave = await kmean.toJSON()
+    const ksaveModel = await fromJSON(ksave)
     expect(centroids).toEqual(ksaveModel.clusterCenters.arraySync())
   })
 

diff --git a/src/cluster/KMeans.ts b/src/cluster/KMeans.ts
@@ -1,6 +1,6 @@
 import { Scikit2D } from '../types'
 import { convertToNumericTensor2D, sampleWithoutReplacement } from '../utils'
-import Serialize from '../serialize'
+import { Serialize } from '../simpleSerializer'
 import { tf } from '../shared/globals'
 
 /*

diff --git a/src/compose/ColumnTransformer.test.ts b/src/compose/ColumnTransformer.test.ts
@@ -1,6 +1,9 @@
-import { ColumnTransformer } from './ColumnTransformer'
-import { MinMaxScaler } from '../preprocessing/MinMaxScaler'
-import { SimpleImputer } from '../impute/SimpleImputer'
+import {
+  fromJSON,
+  SimpleImputer,
+  MinMaxScaler,
+  ColumnTransformer
+} from '../index'
 import * as dfd from 'danfojs-node'
 
 describe('ColumnTransformer', function () {
@@ -30,4 +33,26 @@ describe('ColumnTransformer', function () {
 
     expect(result.arraySync()).toEqual(expected)
   })
+  it('ColumnTransformer serialize/deserialize test', async function () {
+    const X = [
+      [2, 2], // [1, .5]
+      [2, 3], // [1, .75]
+      [0, NaN], // [0, 1]
+      [2, 0] // [.5, 0]
+    ]
+    let newDf = new dfd.DataFrame(X)
+
+    const transformer = new ColumnTransformer({
+      transformers: [
+        ['minmax', new MinMaxScaler(), [0]],
+        ['simpleImpute', new SimpleImputer({ strategy: 'median' }), [1]]
+      ]
+    })
+
+    transformer.fitTransform(newDf)
+    let obj = await transformer.toJSON()
+    let myResult = await fromJSON(obj)
+
+    expect(myResult.transformers.length).toEqual(2)
+  })
 })
diff --git a/src/compose/ColumnTransformer.ts b/src/compose/ColumnTransformer.ts
@@ -1,5 +1,6 @@
-import { DataFrameInterface, Scikit1D, Scikit2D, Transformer } from '../types'
-import { isDataFrameInterface, isScikitLike2D } from '../typesUtils'
+import { DataFrameInterface, Scikit1D, Transformer } from '../types'
+import { isDataFrameInterface } from '../typesUtils'
+import { Serialize } from '../simpleSerializer'
 import { tf } from '../shared/globals'
 /*
 Next steps:
@@ -64,7 +65,7 @@ export interface ColumnTransformerParams {
     ]
  * ```
  */
-export class ColumnTransformer {
+export class ColumnTransformer extends Serialize {
   transformers: TransformerTriple
   remainder: Transformer | 'drop' | 'passthrough'
 
@@ -75,6 +76,7 @@ export class ColumnTransformer {
     transformers = [],
     remainder = 'drop'
   }: ColumnTransformerParams = {}) {
+    super()
     this.transformers = transformers
     this.remainder = remainder
   }

diff --git a/src/dummy/DummyClassifier.test.ts b/src/dummy/DummyClassifier.test.ts
@@ -1,5 +1,4 @@
-import { DummyClassifier } from './DummyClassifier'
-
+import { DummyClassifier, fromJSON } from '../index'
 describe('DummyClassifier', function () {
   it('Use DummyClassifier on simple example (mostFrequent)', function () {
     const clf = new DummyClassifier()
@@ -51,7 +50,7 @@ describe('DummyClassifier', function () {
 
     expect(scaler.classes).toEqual([1, 2, 3])
   })
-  it('should serialize DummyClassifier', function () {
+  it('should serialize DummyClassifier', async function () {
     const clf = new DummyClassifier()
 
     const X = [
@@ -70,10 +69,10 @@ describe('DummyClassifier', function () {
     }
 
     clf.fit(X, y)
-    const clfSave = clf.toJson() as string
-    expect(expectedResult).toEqual(JSON.parse(clfSave))
+    const clfSave = await clf.toObject()
+    expect(expectedResult).toEqual(clfSave)
   })
-  it('should load DummyClassifier', function () {
+  it('should load DummyClassifier', async function () {
     const clf = new DummyClassifier()
 
     const X = [
@@ -85,8 +84,8 @@ describe('DummyClassifier', function () {
     const y = [10, 20, 20, 30]
 
     clf.fit(X, y)
-    const clfSave = clf.toJson() as string
-    const newClf = new DummyClassifier().fromJson(clfSave)
+    const clfSave = await clf.toJSON()
+    const newClf = await fromJSON(clfSave)
     expect(clf).toEqual(newClf)
   })
 })
diff --git a/src/dummy/DummyRegressor.test.ts b/src/dummy/DummyRegressor.test.ts
@@ -1,4 +1,4 @@
-import { DummyRegressor } from './DummyRegressor'
+import { DummyRegressor, fromJSON } from '../index'
 
 describe('DummyRegressor', function () {
   it('Use DummyRegressor on simple example (mean)', function () {
@@ -55,7 +55,7 @@ describe('DummyRegressor', function () {
     reg.fit(X, y)
     expect(reg.predict(predictX).arraySync()).toEqual([10, 10, 10])
   })
-  it('Should save DummyRegressor', function () {
+  it('Should save DummyRegressor', async function () {
     const reg = new DummyRegressor({ strategy: 'constant', constant: 10 })
 
     const X = [
@@ -68,15 +68,16 @@ describe('DummyRegressor', function () {
       name: 'DummyRegressor',
       EstimatorType: 'regressor',
       strategy: 'constant',
-      constant: 10
+      constant: 10,
+      quantile: undefined
     }
 
     reg.fit(X, y)
 
-    expect(saveResult).toEqual(JSON.parse(reg.toJson() as string))
+    expect(saveResult).toEqual(await reg.toObject())
   })
 
-  it('Should load serialized DummyRegressor', function () {
+  it('Should load serialized DummyRegressor', async function () {
     const reg = new DummyRegressor({ strategy: 'constant', constant: 10 })
 
     const X = [
@@ -92,8 +93,8 @@ describe('DummyRegressor', function () {
     ]
 
     reg.fit(X, y)
-    const saveReg = reg.toJson() as string
-    const newReg = new DummyRegressor().fromJson(saveReg)
+    const saveReg = await reg.toJSON()
+    const newReg = await fromJSON(saveReg)
 
     expect(newReg.predict(predictX).arraySync()).toEqual([10, 10, 10])
   })

diff --git a/src/ensemble/VotingClassifier.test.ts b/src/ensemble/VotingClassifier.test.ts
@@ -1,7 +1,10 @@
-import { makeVotingClassifier, VotingClassifier } from './VotingClassifier'
-import { DummyClassifier } from '../dummy/DummyClassifier'
-
-import { LogisticRegression } from '../linear_model/LogisticRegression'
+import {
+  makeVotingClassifier,
+  VotingClassifier,
+  DummyClassifier,
+  LogisticRegression,
+  fromJSON
+} from '../index'
 
 describe('VotingClassifier', function () {
   it('Use VotingClassifier on simple example (voting = hard)', async function () {
@@ -118,8 +121,8 @@ describe('VotingClassifier', function () {
 
     await voter.fit(X, y)
 
-    const savedModel = (await voter.toJson()) as string
-    const newModel = new VotingClassifier({}).fromJson(savedModel)
+    const savedModel = await voter.toJSON()
+    const newModel = await fromJSON(savedModel)
 
     expect(newModel.predict(X).arraySync()).toEqual([1, 1, 1, 1, 1])
   }, 30000)

diff --git a/src/ensemble/VotingClassifier.ts b/src/ensemble/VotingClassifier.ts
@@ -2,7 +2,6 @@ import { Scikit1D, Scikit2D } from '../types'
 import { tf } from '../shared/globals'
 import { ClassifierMixin } from '../mixins'
 import { LabelEncoder } from '../preprocessing/LabelEncoder'
-import { fromJson, toJson } from './serializeEnsemble'
 
 /*
   Next steps:
@@ -154,15 +153,6 @@ export class VotingClassifier extends ClassifierMixin {
   ): Promise<Array<tf.Tensor1D> | Array<tf.Tensor2D>> {
     return (await this.fit(X, y)).transform(X)
   }
-
-  public fromJson(model: string) {
-    return fromJson(this, model)
-  }
-
-  public async toJson(): Promise<string> {
-    const classJson = JSON.parse(super.toJson() as string)
-    return toJson(this, classJson)
-  }
 }
 
 export function makeVotingClassifier(...args: any[]) {

diff --git a/src/ensemble/VotingRegressor.test.ts b/src/ensemble/VotingRegressor.test.ts
@@ -1,6 +1,10 @@
-import { makeVotingRegressor, VotingRegressor } from './VotingRegressor'
-import { DummyRegressor } from '../dummy/DummyRegressor'
-import { LinearRegression } from '../linear_model/LinearRegression'
+import {
+  makeVotingRegressor,
+  VotingRegressor,
+  fromJSON,
+  DummyRegressor,
+  LinearRegression
+} from '../index'
 
 describe('VotingRegressor', function () {
   it('Use VotingRegressor on simple example ', async function () {
@@ -51,8 +55,8 @@ describe('VotingRegressor', function () {
 
     await voter.fit(X, y)
 
-    const savedModel = (await voter.toJson()) as string
-    const newModel = new VotingRegressor({}).fromJson(savedModel)
+    const savedModel = await voter.toJSON()
+    const newModel = await fromJSON(savedModel)
     expect(newModel.score(X, y)).toEqual(voter.score(X, y))
   }, 30000)
 })
diff --git a/src/ensemble/VotingRegressor.ts b/src/ensemble/VotingRegressor.ts
@@ -1,7 +1,6 @@
 import { Scikit1D, Scikit2D } from '../types'
 import { tf } from '../shared/globals'
 import { RegressorMixin } from '../mixins'
-import { fromJson, toJson } from './serializeEnsemble'
 /*
   Next steps:
   0. Write validation code to check Estimator inputs
@@ -95,15 +94,6 @@ export class VotingRegressor extends RegressorMixin {
   public async fitTransform(X: Scikit2D, y: Scikit1D) {
     return (await this.fit(X, y)).transform(X)
   }
-
-  public fromJson(model: string) {
-    return fromJson(this, model) as this
-  }
-
-  public async toJson(): Promise<string> {
-    const classJson = JSON.parse(super.toJson() as string)
-    return toJson(this, classJson)
-  }
 }
 
 /**