Test the layer directly (#18)

Author: ishii-norimi

lib/model/nns/layer/additive_coupling.js

@@ -59,7 +59,7 @@ export default class AdditiveCoupling extends FlowLayer {
 	toObject() {
 		return {
 			type: 'additive_coupling',
-			net: this._m.toObject(),
+			net: this._m?.toObject(),
 		}
 	}
 }

lib/model/nns/layer/rnn.js

@@ -129,7 +129,8 @@ export default class RNNLayer extends Layer {
 	toObject() {
 		return {
 			type: 'rnn',
-			out_size: this._size,
+			size: this._size,
+			out_size: this._out_size,
 			return_sequences: this._return_sequences,
 			w_hy: this._w_hy.toArray(),
 			b_hy: this._b_hy.toArray(),

tests/lib/model/nns/layer/abs.test.js

@@ -1,7 +1,50 @@
 import NeuralNetwork from '../../../../../lib/model/neuralnetwork.js'
 import Matrix from '../../../../../lib/util/matrix.js'
 
-describe('abs', () => {
+import Layer from '../../../../../lib/model/nns/layer/base.js'
+
+describe('layer', () => {
+	test('construct', () => {
+		const layer = Layer.fromObject({ type: 'abs' })
+		expect(layer).toBeDefined()
+	})
+
+	test('calc', () => {
+		const layer = Layer.fromObject({ type: 'abs' })
+
+		const x = Matrix.randn(100, 10)
+		const y = layer.calc(x)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(y.at(i, j)).toBeCloseTo(Math.abs(x.at(i, j)))
+			}
+		}
+	})
+
+	test('grad', () => {
+		const layer = Layer.fromObject({ type: 'abs' })
+
+		const x = Matrix.randn(100, 10)
+		layer.calc(x)
+
+		const bo = Matrix.ones(100, 10)
+		const bi = layer.grad(bo)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(bi.at(i, j)).toBeCloseTo(Math.sign(x.at(i, j)))
+			}
+		}
+	})
+
+	test('toObject', () => {
+		const layer = Layer.fromObject({ type: 'abs' })
+
+		const obj = layer.toObject()
+		expect(obj).toEqual({ type: 'abs' })
+	})
+})
+
+describe('nn', () => {
 	test('calc', () => {
 		const net = NeuralNetwork.fromObject([{ type: 'input' }, { type: 'abs' }])
 		const x = Matrix.randn(10, 10)

tests/lib/model/nns/layer/acos.test.js

@@ -1,7 +1,50 @@
 import NeuralNetwork from '../../../../../lib/model/neuralnetwork.js'
 import Matrix from '../../../../../lib/util/matrix.js'
 
-describe('acos', () => {
+import Layer from '../../../../../lib/model/nns/layer/base.js'
+
+describe('layer', () => {
+	test('construct', () => {
+		const layer = Layer.fromObject({ type: 'acos' })
+		expect(layer).toBeDefined()
+	})
+
+	test('calc', () => {
+		const layer = Layer.fromObject({ type: 'acos' })
+
+		const x = Matrix.random(100, 10, -1, 1)
+		const y = layer.calc(x)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(y.at(i, j)).toBeCloseTo(Math.acos(x.at(i, j)))
+			}
+		}
+	})
+
+	test('grad', () => {
+		const layer = Layer.fromObject({ type: 'acos' })
+
+		const x = Matrix.random(100, 10, -1, 1)
+		layer.calc(x)
+
+		const bo = Matrix.ones(100, 10)
+		const bi = layer.grad(bo)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(bi.at(i, j)).toBeCloseTo(-1 / (Math.sqrt(1 - x.at(i, j) ** 2) + 1.0e-4))
+			}
+		}
+	})
+
+	test('toObject', () => {
+		const layer = Layer.fromObject({ type: 'acos' })
+
+		const obj = layer.toObject()
+		expect(obj).toEqual({ type: 'acos' })
+	})
+})
+
+describe('nn', () => {
 	test('calc', () => {
 		const net = NeuralNetwork.fromObject([{ type: 'input' }, { type: 'acos' }])
 		const x = Matrix.random(10, 10, -1, 1)

tests/lib/model/nns/layer/acosh.test.js

@@ -1,7 +1,50 @@
 import NeuralNetwork from '../../../../../lib/model/neuralnetwork.js'
 import Matrix from '../../../../../lib/util/matrix.js'
 
-describe('acosh', () => {
+import Layer from '../../../../../lib/model/nns/layer/base.js'
+
+describe('layer', () => {
+	test('construct', () => {
+		const layer = Layer.fromObject({ type: 'acosh' })
+		expect(layer).toBeDefined()
+	})
+
+	test('calc', () => {
+		const layer = Layer.fromObject({ type: 'acosh' })
+
+		const x = Matrix.random(100, 10, 1, 5)
+		const y = layer.calc(x)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(y.at(i, j)).toBeCloseTo(Math.acosh(x.at(i, j)))
+			}
+		}
+	})
+
+	test('grad', () => {
+		const layer = Layer.fromObject({ type: 'acosh' })
+
+		const x = Matrix.random(100, 10, 1, 5)
+		layer.calc(x)
+
+		const bo = Matrix.ones(100, 10)
+		const bi = layer.grad(bo)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(bi.at(i, j)).toBeCloseTo(1 / (Math.sqrt(x.at(i, j) ** 2 - 1) + 1.0e-4))
+			}
+		}
+	})
+
+	test('toObject', () => {
+		const layer = Layer.fromObject({ type: 'acosh' })
+
+		const obj = layer.toObject()
+		expect(obj).toEqual({ type: 'acosh' })
+	})
+})
+
+describe('nn', () => {
 	test('calc', () => {
 		const net = NeuralNetwork.fromObject([{ type: 'input' }, { type: 'acosh' }])
 		const x = Matrix.random(10, 10, 1, 5)

tests/lib/model/nns/layer/add.test.js

@@ -1,7 +1,54 @@
 import NeuralNetwork from '../../../../../lib/model/neuralnetwork.js'
 import Matrix from '../../../../../lib/util/matrix.js'
 
-describe('add', () => {
+import AddLayer from '../../../../../lib/model/nns/layer/add.js'
+
+describe('layer', () => {
+	test('construct', () => {
+		const layer = new AddLayer({})
+		expect(layer).toBeDefined()
+	})
+
+	test('calc', () => {
+		const layer = new AddLayer({})
+
+		const x1 = Matrix.randn(100, 10)
+		const x2 = Matrix.randn(100, 10)
+		const y = layer.calc(x1, x2)
+		for (let i = 0; i < x1.rows; i++) {
+			for (let j = 0; j < x1.cols; j++) {
+				expect(y.at(i, j)).toBeCloseTo(x1.at(i, j) + x2.at(i, j))
+			}
+		}
+	})
+
+	test('grad', () => {
+		const layer = new AddLayer({})
+
+		const x1 = Matrix.randn(100, 10)
+		const x2 = Matrix.randn(100, 10)
+		layer.calc(x1, x2)
+
+		const bo = Matrix.ones(100, 10)
+		const bi = layer.grad(bo)
+		expect(bi).toHaveLength(2)
+		for (let i = 0; i < x1.rows; i++) {
+			for (let j = 0; j < x1.cols; j++) {
+				expect(bi[0].at(i, j)).toBe(1)
+				expect(bi[1].at(i, j)).toBe(1)
+			}
+		}
+	})
+
+	test('toObject', () => {
+		const layer = new AddLayer({})
+
+		const obj = layer.toObject()
+		expect(obj).toEqual({ type: 'add' })
+	})
+})
+
+describe('nn', () => {
 	test('calc', () => {
 		const net = NeuralNetwork.fromObject([
 			{ type: 'input', name: 'a' },

tests/lib/model/nns/layer/additive_coupling.test.js

@@ -1,7 +1,70 @@
 import NeuralNetwork from '../../../../../lib/model/neuralnetwork.js'
 import Matrix from '../../../../../lib/util/matrix.js'
 
-describe('additive_coupling', () => {
+import AdditiveCoupling from '../../../../../lib/model/nns/layer/additive_coupling.js'
+
+describe('layer', () => {
+	test('construct', () => {
+		const layer = new AdditiveCoupling({})
+		expect(layer).toBeDefined()
+	})
+
+	test('calc', () => {
+		const layer = new AdditiveCoupling({})
+
+		const x = Matrix.randn(100, 10)
+		const y = layer.calc(x)
+		expect(y.sizes).toEqual(x.sizes)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < Math.floor(x.cols / 2); j++) {
+				expect(y.at(i, j)).toBe(x.at(i, j))
+			}
+			for (let j = Math.floor(x.cols / 2); j < x.cols; j++) {
+				expect(y.at(i, j)).not.toBe(x.at(i, j))
+			}
+		}
+	})
+
+	test('inverse', () => {
+		const layer = new AdditiveCoupling({})
+
+		const x = Matrix.randn(100, 10)
+		const y = layer.calc(x)
+		const x0 = layer.inverse(y)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < x.cols; j++) {
+				expect(x0.at(i, j)).toBeCloseTo(x.at(i, j))
+			}
+		}
+	})
+
+	test('grad', () => {
+		const layer = new AdditiveCoupling({})
+
+		const x = Matrix.randn(100, 10)
+		layer.calc(x)
+
+		const bo = Matrix.ones(100, 10)
+		const bi = layer.grad(bo)
+		for (let i = 0; i < x.rows; i++) {
+			for (let j = 0; j < Math.floor(x.cols / 2); j++) {
+				expect(bi.at(i, j)).not.toBe(1)
+			}
+			for (let j = Math.floor(x.cols / 2); j < x.cols; j++) {
+				expect(bi.at(i, j)).toBe(1)
+			}
+		}
+	})
+
+	test('toObject', () => {
+		const layer = new AdditiveCoupling({})
+
+		const obj = layer.toObject()
+		expect(obj.type).toBe('additive_coupling')
+	})
+})
+
+describe('nn', () => {
 	test('calc', () => {
 		const net = NeuralNetwork.fromObject([{ type: 'input' }, { type: 'additive_coupling' }])
 		const x = Matrix.randn(10, 10)
@@ -12,6 +75,9 @@ describe('additive_coupling', () => {
 			for (let j = 0; j < Math.floor(x.cols / 2); j++) {
 				expect(y.at(i, j)).toBe(x.at(i, j))
 			}
+			for (let j = Math.floor(x.cols / 2); j < x.cols; j++) {
+				expect(y.at(i, j)).not.toBe(x.at(i, j))
+			}
 		}
 	})
 

tests/lib/model/nns/layer/argmax.test.js

@@ -4,7 +4,45 @@ jest.retryTimes(3)
 import NeuralNetwork from '../../../../../lib/model/neuralnetwork.js'
 import Matrix from '../../../../../lib/util/matrix.js'
 
-describe('argmax', () => {
+import ArgmaxLayer from '../../../../../lib/model/nns/layer/argmax.js'
+
+describe('layer', () => {
+	test('construct', () => {
+		const layer = new ArgmaxLayer({})
+		expect(layer).toBeDefined()
+	})
+
+	test('calc', () => {
+		const layer = new ArgmaxLayer({})
+
+		const x = Matrix.randn(100, 10)
+		const y = layer.calc(x)
+		const t = x.argmax(1)
+		for (let i = 0; i < x.rows; i++) {
+			expect(y.at(i, 0)).toBeCloseTo(t.at(i, 0))
+		}
+	})
+
+	test('grad', () => {
+		const layer = new ArgmaxLayer({})
+
+		const x = Matrix.randn(100, 10)
+		layer.calc(x)
+
+		const bo = Matrix.ones(100, 1)
+		const bi = layer.grad(bo)
+		expect(bi.sizes).toEqual([100, 10])
+	})
+
+	test('toObject', () => {
+		const layer = new ArgmaxLayer({})
+
+		const obj = layer.toObject()
+		expect(obj).toEqual({ type: 'argmax' })
+	})
+})
+
+describe('nn', () => {
 	test('calc', () => {
 		const net = NeuralNetwork.fromObject([{ type: 'input' }, { type: 'argmax' }])
 		const x = Matrix.random(10, 10, 0, 1)