Merge pull request #700 from loredanacirstea/types-fix

Fix remaining lint:typecheck errors

Author: robertleeplummerjr

__tests__/feed-forward/end-to-end.ts

@@ -8,14 +8,15 @@ import {
   Target,
   Sigmoid,
   arthurFeedForward,
+  ILayer,
+  ILayerSettings,
 } from '../../src/layer';
 import { feedForward as feedForwardLayer } from '../../src/layer/feed-forward';
 
 import { momentumRootMeanSquaredPropagation } from '../../src/praxis';
 import { zeros2D } from '../../src/utilities/zeros-2d';
 import { setup, teardown } from '../../src/utilities/kernel';
 import { mockPraxis } from '../test-utils';
-import { ILayer, ILayerSettings } from '../../src/layer';
 import { IPraxis } from '../../src/praxis/base-praxis';
 
 const xorTrainingData = [

__tests__/feed-forward/unit.ts

@@ -25,7 +25,7 @@ import {
   layerTypes,
   ILayer,
   ILayerJSON,
-  ILayerSettings
+  ILayerSettings,
 } from '../../src/layer';
 import { mockLayer, mockPraxis } from '../test-utils';
 import SpyInstance = jest.SpyInstance;

__tests__/layer/lstm-cell.ts

@@ -5,7 +5,8 @@ import {
   MultiplyElement,
   Random,
   RecurrentZeros,
-  Sigmoid, Tanh,
+  Sigmoid,
+  Tanh,
   Zeros,
 } from '../../src/layer';
 import { mockLayer, onePlusPlus2D, TestLayer } from '../test-utils';
@@ -165,15 +166,19 @@ describe('lstm Cell', () => {
       const layer = lstmCell(settings, input, recurrentInput);
       const layers = flattenLayers([layer]);
 
-      recurrentInput.weights = onePlusPlus2D(recurrentInput.width, recurrentInput.height);
-      const memoryLayers = layers.filter((layer: ILayer) => layer instanceof Random);
-      memoryLayers
-        .forEach((layer: ILayer) => {
-          layer.weights = onePlusPlus2D(layer.width, layer.height);
-        });
-
-      layers.forEach(layer => layer.setupKernels());
-      layers.forEach(layer => layer.predict());
+      recurrentInput.weights = onePlusPlus2D(
+        recurrentInput.width,
+        recurrentInput.height
+      );
+      const memoryLayers = layers.filter(
+        (layer: ILayer) => layer instanceof Random
+      );
+      memoryLayers.forEach((layer: ILayer) => {
+        layer.weights = onePlusPlus2D(layer.width, layer.height);
+      });
+
+      layers.forEach((layer) => layer.setupKernels());
+      layers.forEach((layer) => layer.predict());
 
       expect(layers[layers.length - 1].weights).toEqual([
         Float32Array.from([0.9640275835990906]),

__tests__/layer/rnn-cell.ts

@@ -1,4 +1,12 @@
-import { rnnCell, RecurrentZeros, Add, Random, Zeros, Multiply, Relu } from '../../src/layer/';
+import {
+  rnnCell,
+  RecurrentZeros,
+  Add,
+  Random,
+  Zeros,
+  Multiply,
+  Relu,
+} from '../../src/layer/';
 import { mockLayer, TestLayer } from '../test-utils';
 import { flattenLayers } from '../../src/utilities/flatten-layers';
 

__tests__/praxis/arthur-deviation-biases/end-to-end.ts

@@ -39,9 +39,7 @@ describe('ArthurDeviationBiases', () => {
       const praxis = new ArthurDeviationBiases(layer1, {
         learningRate: net.trainOpts.learningRate,
       });
-      expect(praxis.settings.learningRate).toBe(
-        net.trainOpts.learningRate
-      );
+      expect(praxis.settings.learningRate).toBe(net.trainOpts.learningRate);
 
       net.deltas[0][0] = 1;
       net.deltas[0][1] = 2;

__tests__/recurrent/unit.ts

@@ -1,5 +1,14 @@
 import { GPU } from 'gpu.js';
-import { add, input, multiply, output, random, rnnCell, IRecurrentInput, ILayer } from '../../src/layer';
+import {
+  add,
+  input,
+  multiply,
+  output,
+  random,
+  rnnCell,
+  IRecurrentInput,
+  ILayer,
+} from '../../src/layer';
 import { Filter } from '../../src/layer/filter';
 import { Recurrent } from '../../src/recurrent';
 import { Matrix } from '../../src/recurrent/matrix';
@@ -334,12 +343,16 @@ describe('Recurrent Class: Unit', () => {
           layers[10].toJSON(),
           { ...layers[11].toJSON(), inputLayer1Index: 10, inputLayer2Index: 9 },
           layers[12].toJSON(),
-          { ...layers[13].toJSON(), inputLayer1Index: 11, inputLayer2Index: 12 },
+          {
+            ...layers[13].toJSON(),
+            inputLayer1Index: 11,
+            inputLayer2Index: 12,
+          },
           { ...layers[14].toJSON(), inputLayerIndex: 13 },
         ],
         outputLayerIndex: 14,
         sizes: [1, 3, 1],
-        type: 'Recurrent'
+        type: 'Recurrent',
       });
     });
   });

__tests__/recurrent_deprecated/gru.ts

@@ -1,5 +1,5 @@
 import { GRU } from '../../src/recurrent/gru';
-import { IMatrixJSON } from '../../src/recurrent/matrix';
+import { IMatrixJSON, Matrix } from '../../src/recurrent/matrix';
 import { RNN } from '../../src/recurrent/rnn';
 import { DataFormatter } from '../../src/utilities/data-formatter';
 
@@ -106,7 +106,7 @@ describe('GRU', () => {
         });
         const json = net.toJSON();
 
-        function compare(left: IMatrixJSON, right: IMatrixJSON) {
+        function compare(left: IMatrixJSON, right: Matrix) {
           left.weights.forEach((value, i) => {
             expect(value).toBe(right.weights[i]);
           });

__tests__/recurrent_deprecated/rnn-time-step.ts

@@ -3,7 +3,10 @@ import { LSTMTimeStep } from '../../src/recurrent/lstm-time-step';
 import { Matrix } from '../../src/recurrent/matrix';
 import { Equation } from '../../src/recurrent/matrix/equation';
 import { IRNNStatus } from '../../src/recurrent/rnn';
-import { RNNTimeStep } from '../../src/recurrent/rnn-time-step';
+import {
+  RNNTimeStep,
+  IRNNTimeStepJSON,
+} from '../../src/recurrent/rnn-time-step';
 
 // TODO: break out LSTMTimeStep into its own tests
 
@@ -18,7 +21,7 @@ describe('RNNTimeStep', () => {
         fromJSONSpy.mockRestore();
       });
       it('calls this.fromJSON with this value', () => {
-        const json = {
+        const json: IRNNTimeStepJSON = {
           type: 'RNNTimeStep',
           options: {
             inputSize: 1,
@@ -33,21 +36,21 @@ describe('RNNTimeStep', () => {
           },
           hiddenLayers: [
             {
-              weight: { rows: 1, columns: 1, weights: Float32Array.from([1]) },
+              weight: { rows: 1, columns: 1, weights: [1] },
               transition: {
                 rows: 1,
                 columns: 1,
-                weights: Float32Array.from([1]),
+                weights: [1],
               },
-              bias: { rows: 1, columns: 1, weights: Float32Array.from([1]) },
+              bias: { rows: 1, columns: 1, weights: [1] },
             },
           ],
           outputConnector: {
             rows: 1,
             columns: 1,
-            weights: Float32Array.from([1]),
+            weights: [1],
           },
-          output: { rows: 1, columns: 1, weights: Float32Array.from([1]) },
+          output: { rows: 1, columns: 1, weights: [1] },
           inputLookup: { a: 0 },
           inputLookupLength: 1,
           outputLookup: { a: 0 },

__tests__/utilities/layer-from-json.ts

@@ -1,4 +1,11 @@
-import { Add, Convolution, ILayerJSON, RecurrentZeros, Sigmoid, Target } from '../../src/layer';
+import {
+  Add,
+  Convolution,
+  ILayerJSON,
+  RecurrentZeros,
+  Sigmoid,
+  Target,
+} from '../../src/layer';
 import { layerFromJSON } from '../../src/utilities/layer-from-json';
 import { mockLayer } from '../test-utils';
 
@@ -37,7 +44,9 @@ describe('layerFromJSON', () => {
         height: 1,
         depth: 1,
       });
-      expect(layerFromJSON(jsonLayer, inputLayer)).toEqual(new Convolution(jsonLayer, inputLayer));
+      expect(layerFromJSON(jsonLayer, inputLayer)).toEqual(
+        new Convolution(jsonLayer, inputLayer)
+      );
     });
   });
   describe('when used with a Activation layer json', () => {
@@ -53,7 +62,9 @@ describe('layerFromJSON', () => {
     });
     it('should return that type instantiated', () => {
       const inputLayer1 = mockLayer();
-      expect(layerFromJSON(jsonLayer, inputLayer1)).toEqual(new Sigmoid(inputLayer1, jsonLayer));
+      expect(layerFromJSON(jsonLayer, inputLayer1)).toEqual(
+        new Sigmoid(inputLayer1, jsonLayer)
+      );
     });
   });
   describe('when used with a Operator layer json', () => {
@@ -81,12 +92,16 @@ describe('layerFromJSON', () => {
     });
     it('fails if inputLayer2 falsey', () => {
       const inputLayer1 = mockLayer();
-      expect(() => layerFromJSON(jsonLayer, inputLayer1)).toThrow('inputLayer2 missing');
+      expect(() => layerFromJSON(jsonLayer, inputLayer1)).toThrow(
+        'inputLayer2 missing'
+      );
     });
     it('should return that type instantiated', () => {
       const inputLayer1 = mockLayer();
       const inputLayer2 = mockLayer();
-      expect(layerFromJSON(jsonLayer, inputLayer1, inputLayer2)).toEqual(new Add(inputLayer1, inputLayer2, jsonLayer));
+      expect(layerFromJSON(jsonLayer, inputLayer1, inputLayer2)).toEqual(
+        new Add(inputLayer1, inputLayer2, jsonLayer)
+      );
     });
   });
   describe('when used with a TargetType layer json', () => {
@@ -102,7 +117,9 @@ describe('layerFromJSON', () => {
     });
     it('should return that type instantiated', () => {
       const inputLayer = mockLayer();
-      expect(layerFromJSON(jsonLayer, inputLayer)).toEqual(new Target(jsonLayer, inputLayer));
+      expect(layerFromJSON(jsonLayer, inputLayer)).toEqual(
+        new Target(jsonLayer, inputLayer)
+      );
     });
   });
 });

src/layer/dropout.ts

@@ -59,8 +59,8 @@ export class Dropout extends Filter {
   dropouts: KernelOutput | null;
   predictKernelMap: IKernelMapRunShortcut<ISubKernelObject> | null = null;
   settings: Partial<IDropoutSettings>;
-  constructor(inputLayer: ILayer, settings?: Partial<IDropoutSettings>) {
-    super(inputLayer);
+  constructor(inputLayer: ILayer, settings: Partial<IDropoutSettings> = {}) {
+    super(settings, inputLayer);
     this.settings = { ...dropoutDefaults, ...settings };
     this.dropouts = null;
     this.validate();

src/layer/fully-connected.ts

@@ -174,7 +174,7 @@ export class FullyConnected extends Filter {
   compareInputDeltasKernel: IKernelRunShortcut | null = null;
   compareBiasesKernel: IKernelRunShortcut | null = null;
   constructor(settings: IFullyConnectedDefaultSettings, inputLayer: ILayer) {
-    super(inputLayer);
+    super(settings, inputLayer);
     this.settings = { ...settings };
     this.validate();
 

src/recurrent/matrix/index.ts

@@ -80,11 +80,7 @@ export class Matrix {
     };
   }
 
-  static fromJSON(json: {
-    rows: number;
-    columns: number;
-    weights: number[];
-  }): Matrix {
+  static fromJSON(json: IMatrixJSON): Matrix {
     const matrix = new Matrix(json.rows, json.columns);
 
     for (let i = 0, max = json.rows * json.columns; i < max; i++) {

src/recurrent/rnn.ts

@@ -58,7 +58,7 @@ export interface IRNNJSONOptions {
 export interface IRNNTrainingOptions {
   iterations: number;
   errorThresh: number;
-  log: boolean | ((status: INeuralNetworkState) => void);
+  log: boolean | ((status: string) => void);
   logPeriod: number;
   learningRate: number;
   callback?: (status: IRNNStatus) => void;
@@ -69,7 +69,7 @@ export interface IRNNTrainingOptions {
 export interface IRNNJSONTrainOptions {
   iterations: number;
   errorThresh: number;
-  log: boolean | ((status: INeuralNetworkState) => void);
+  log: boolean | ((status: string) => void);
   logPeriod: number;
   learningRate: number;
   callback?: (status: IRNNStatus) => void;