Make knn test better

Author: r59q

src/__tests__/ml/classifier.test.ts

@@ -230,68 +230,73 @@ describe('Classifier tests', () => {
     expect(get(confidences).size).toBe(3);
   });
 
-  test('Classifier should correctly classify', async () => {
-    const vectors = [
-      new BaseVector([1, 2, 4], ['x', 'y', 'z']),
-      new BaseVector([4, 8, 16], ['x', 'y', 'z']),
-      new BaseVector([10, 20, 40], ['x', 'y', 'z']),
-    ];
-    const classifierInput = new ClassifierInput(vectors);
-    const filterMax: Filter = FilterTypes.createFilter(FilterType.MAX);
-    const filterMean: Filter = FilterTypes.createFilter(FilterType.MEAN);
-    const filterMin: Filter = FilterTypes.createFilter(FilterType.MIN);
-    const filters: Filters = new Filters(writable([filterMax, filterMean, filterMin]));
-
-    let iterations = 0;
-
-    const trainingData = new TestTrainingDataRepository().getTrainingData();
-    const trainedModel = await new LayersModelTrainer(
-      StaticConfiguration.defaultNeuralNetworkSettings,
-      () => (iterations += 1),
-    ).trainModel(trainingData);
-    const model = writable(trainedModel);
-
-    const gestureRepository = new TestGestureRepository();
-    gestureRepository.addGesture({
-      color: 'blue',
-      ID: 1,
-      name: 'test',
-      output: {},
-      recordings: [],
-    });
-    gestureRepository.addGesture({
-      color: 'blue',
-      ID: 2,
-      name: 'test',
-      output: {},
-      recordings: [],
-    });
-    gestureRepository.addGesture({
-      color: 'blue',
-      ID: 3,
-      name: 'test',
-      output: {},
-      recordings: [],
-    });
-
-    const confidences = new Confidences();
-
-    const classifier = new ClassifierFactory().buildClassifier(
-      model,
-      async () => void 0,
-      filters,
-      gestureRepository,
-      (gestureId, confidence) => confidences.setConfidence(gestureId, confidence),
-      new Snackbar(),
-    );
-
-    // This is based on known correct results
-    await classifier.classify(classifierInput)
-
-    expect(get(confidences).get(1)).toBeCloseTo(0);
-    expect(get(confidences).get(2)).toBeCloseTo(0);
-    expect(get(confidences).get(3)).toBeCloseTo(1);
-  }, {
-    repeats: 20, retry: 2
-  });
+  test(
+    'Classifier should correctly classify',
+    async () => {
+      const vectors = [
+        new BaseVector([1, 2, 4], ['x', 'y', 'z']),
+        new BaseVector([4, 8, 16], ['x', 'y', 'z']),
+        new BaseVector([10, 20, 40], ['x', 'y', 'z']),
+      ];
+      const classifierInput = new ClassifierInput(vectors);
+      const filterMax: Filter = FilterTypes.createFilter(FilterType.MAX);
+      const filterMean: Filter = FilterTypes.createFilter(FilterType.MEAN);
+      const filterMin: Filter = FilterTypes.createFilter(FilterType.MIN);
+      const filters: Filters = new Filters(writable([filterMax, filterMean, filterMin]));
+
+      let iterations = 0;
+
+      const trainingData = new TestTrainingDataRepository().getTrainingData();
+      const trainedModel = await new LayersModelTrainer(
+        StaticConfiguration.defaultNeuralNetworkSettings,
+        () => (iterations += 1),
+      ).trainModel(trainingData);
+      const model = writable(trainedModel);
+
+      const gestureRepository = new TestGestureRepository();
+      gestureRepository.addGesture({
+        color: 'blue',
+        ID: 1,
+        name: 'test',
+        output: {},
+        recordings: [],
+      });
+      gestureRepository.addGesture({
+        color: 'blue',
+        ID: 2,
+        name: 'test',
+        output: {},
+        recordings: [],
+      });
+      gestureRepository.addGesture({
+        color: 'blue',
+        ID: 3,
+        name: 'test',
+        output: {},
+        recordings: [],
+      });
+
+      const confidences = new Confidences();
+
+      const classifier = new ClassifierFactory().buildClassifier(
+        model,
+        async () => void 0,
+        filters,
+        gestureRepository,
+        (gestureId, confidence) => confidences.setConfidence(gestureId, confidence),
+        new Snackbar(),
+      );
+
+      // This is based on known correct results
+      await classifier.classify(classifierInput);
+
+      expect(get(confidences).get(1)).toBeCloseTo(0);
+      expect(get(confidences).get(2)).toBeCloseTo(0);
+      expect(get(confidences).get(3)).toBeCloseTo(1);
+    },
+    {
+      repeats: 20,
+      retry: 2,
+    },
+  );
 });

src/__tests__/ml/model.test.ts

@@ -13,29 +13,30 @@ import KNNModelTrainer from '../../script/mlmodels/KNNModelTrainer';
 import KNNNonNormalizedModelTrainer from '../../script/mlmodels/KNNNonNormalizedModelTrainer';
 
 describe('ML Model tests', async () => {
-    describe("Layers Model", async () => {
-        test('Model should train the expected number of times', async () => {
-            let iterations = 0;
+  describe('Layers Model', async () => {
+    test('Model should train the expected number of times', async () => {
+      let iterations = 0;
 
-            const trainingData = new TestTrainingDataRepository().getTrainingData();
-            await new LayersModelTrainer(
-                StaticConfiguration.defaultNeuralNetworkSettings,
-                () => (iterations += 1),
-            ).trainModel(trainingData);
+      const trainingData = new TestTrainingDataRepository().getTrainingData();
+      await new LayersModelTrainer(
+        StaticConfiguration.defaultNeuralNetworkSettings,
+        () => (iterations += 1),
+      ).trainModel(trainingData);
 
-            expect(iterations).toBe(StaticConfiguration.defaultNeuralNetworkSettings.noOfEpochs);
-        });
-
-
-    })
-    describe("KNN-non normalized Model", async () => {
-        test('Model should train the expected number of times', async () => {
-            let iterations = 0;
-
-            const trainingData = new TestTrainingDataRepository().getTrainingData();
-            const knnModel = await new KNNNonNormalizedModelTrainer(2).trainModel(trainingData);
+      expect(iterations).toBe(
+        StaticConfiguration.defaultNeuralNetworkSettings.noOfEpochs,
+      );
+    });
+  });
+  describe('KNN-non normalized Model', async () => {
+    test('Model should train the expected number of times', async () => {
+      const trainingData = new TestTrainingDataRepository().getTrainingData();
+      const knnModel = await new KNNNonNormalizedModelTrainer(2).trainModel(trainingData);
 
-            expect(async () => await knnModel.predict([0, 0, 0, 0, 0, 0, 0, 0, 0])).not.throws()
-        });
+      const prediction1 = await knnModel.predict([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      expect(prediction1).toStrictEqual([0, 1, 0]);
+      const prediction2 = await knnModel.predict([1, 1, 0, 0, 0, -2, 0, -3, 0]);
+      expect(prediction2).toStrictEqual([0.5, 0, 0.5]);
     });
+  });
 });

src/script/mlmodels/KNNMLModel.ts

@@ -14,7 +14,7 @@ class KNNMLModel implements MLModel {
   ) {}
   public async predict(filteredData: number[]): Promise<number[]> {
     const inputTensor = tensor(filteredData);
-    console.warn(filteredData)
+    console.warn(filteredData);
 
     try {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call