Refactored 'mind' to 'network'

antoniodeluca · Feb 20, 2023 · eb4bad6 · eb4bad6
1 parent e2c820c
commit eb4bad6
Show file tree

Hide file tree

Showing 4 changed files with 47 additions and 47 deletions.
diff --git a/library/assets/core/Cerebrum.ts b/library/assets/core/Cerebrum.ts
@@ -8,15 +8,15 @@ import {
 import {
     CerebrumConfiguration,
     CerebrumInterface,
-    Mind,
-    MindConfiguration,
+    Network,
+    NetworkConfiguration,
 } from "./types";
 import { QueryingInputPatterns, TrainingPatterns } from "./types";
 
 class Cerebrum implements CerebrumInterface {
     private configuration: CerebrumConfiguration;
 
-    private minds: Mind[];
+    private networks: Network[];
 
     private checkConfiguration() {
         return true;
@@ -34,54 +34,54 @@ class Cerebrum implements CerebrumInterface {
         }
         this.configuration = this.transformConfiguration();
 
-        this.minds = [];
+        this.networks = [];
 
-        this.configuration.minds.forEach((configuration) => {
-            this.buildMind(configuration);
+        this.configuration.networks.forEach((configuration) => {
+            this.buildNetwork(configuration);
         });
     }
 
-    buildMind(configuration: MindConfiguration) {
-        this.minds.push({
+    buildNetwork(configuration: NetworkConfiguration) {
+        this.networks.push({
             name: configuration.name,
-            network: configuration.network.generator.getInstance(
-                configuration.network.configuration
+            code: configuration.code.generator.getInstance(
+                configuration.code.configuration
             ),
         });
     }
 
-    trainMind(
+    trainNetwork(
         trainingPatterns: TrainingPatterns,
         epochCallback?: TrainingEpochCallback,
         iterationCallback?: TrainingIterationCallback,
-        mindName = "defaultMind"
+        networkName = "defaultNetwork"
     ) {
-        const mind = this.minds.find((mind) => {
-            return mind.name === mindName;
+        const network = this.networks.find((network) => {
+            return network.name === networkName;
         });
 
-        if (mind === undefined) {
-            throw new Error("Mind not found during training");
+        if (network === undefined) {
+            throw new Error("Network not found during training");
         }
 
-        mind.network.train(trainingPatterns, epochCallback, iterationCallback);
+        network.code.train(trainingPatterns, epochCallback, iterationCallback);
     }
 
-    queryMind(
+    queryNetwork(
         queryingPatterns: QueryingInputPatterns,
         epochCallback?: QueryingEpochCallback,
         iterationCallback?: QueryingIterationCallback,
-        mindName = "defaultMind"
+        networkName = "defaultNetwork"
     ) {
-        const mind = this.minds.find((mind) => {
-            return mind.name === mindName;
+        const network = this.networks.find((network) => {
+            return network.name === networkName;
         });
 
-        if (mind === undefined) {
-            throw new Error("Mind not found during querying");
+        if (network === undefined) {
+            throw new Error("Network not found during querying");
         }
 
-        mind.network.query(queryingPatterns, epochCallback, iterationCallback);
+        network.code.query(queryingPatterns, epochCallback, iterationCallback);
     }
 }
 

diff --git a/library/assets/core/CerebrumFactory.ts b/library/assets/core/CerebrumFactory.ts
@@ -13,16 +13,16 @@ class CerebrumFactory {
         const networkAlphaFactory = new NetworkAlphaFactory(this.calculator);
 
         return {
-            minds: [
+            networks: [
                 {
-                    name: "defaultMind",
-                    network: {
+                    name: "defaultNetwork",
+                    code: {
                         generator: networkAlphaFactory,
                     },
                     inputsFrom: ["cerebrum"],
                 },
             ],
-            outputsFrom: ["defaultMind"],
+            outputsFrom: ["defaultNetwork"],
         } as CerebrumConfiguration;
     }
 

diff --git a/library/assets/core/types.ts b/library/assets/core/types.ts
@@ -52,40 +52,40 @@ interface QueryingStatus {
 }
 
 interface CerebrumInterface {
-    buildMind: (configuration: MindConfiguration) => void;
+    buildNetwork: (configuration: NetworkConfiguration) => void;
 
-    trainMind: (
+    trainNetwork: (
         trainingPatterns: TrainingPatterns,
         epochCallback?: TrainingEpochCallback,
         iterationCallback?: TrainingIterationCallback,
-        mindName?: string
+        networkName?: string
     ) => void;
 
-    queryMind: (
+    queryNetwork: (
         queryingPatterns: QueryingInputPatterns,
         epochCallback?: QueryingEpochCallback,
         iterationCallback?: QueryingIterationCallback,
-        mindName?: string
+        networkName?: string
     ) => void;
 }
 
-interface MindConfiguration {
+interface NetworkConfiguration {
     name: string;
-    network: {
+    code: {
         generator: NetworkAlphaFactory;
         configuration?: NetworkAlphaConfiguration;
     };
     inputsFrom: string[];
 }
 
 interface CerebrumConfiguration {
-    minds: MindConfiguration[];
+    networks: NetworkConfiguration[];
     outputsFrom: string[];
 }
 
-interface Mind {
+interface Network {
     name: string;
-    network: NetworkInterface;
+    code: NetworkInterface;
 }
 
 interface BrainInterface {
@@ -102,8 +102,8 @@ interface BrainConfiguration {
 export {
     CerebrumConfiguration,
     CerebrumInterface,
-    Mind,
-    MindConfiguration,
+    Network,
+    NetworkConfiguration,
     BrainConfiguration,
     BrainInterface,
     TrainingPattern,

diff --git a/library/tests/acceptance/should-be-able-to-solve-the-xor-problem.test.ts b/library/tests/acceptance/should-be-able-to-solve-the-xor-problem.test.ts
@@ -29,10 +29,10 @@ describe("When trained with training examples about the XOR problem", () => {
             cerebrum: {
                 generator: cerebrumFactory,
                 configuration: {
-                    minds: [
+                    networks: [
                         {
-                            name: "defaultMind",
-                            network: {
+                            name: "defaultNetwork",
+                            code: {
                                 generator: networkAlphaFactory,
                                 configuration: {
                                     layerDimensions: [2, 4, 1],
@@ -53,7 +53,7 @@ describe("When trained with training examples about the XOR problem", () => {
                             inputsFrom: ["cerebrum"],
                         },
                     ],
-                    outputsFrom: ["defaultMind"],
+                    outputsFrom: ["defaultNetwork"],
                 } as CerebrumConfiguration,
             },
         });
@@ -100,12 +100,12 @@ describe("When trained with training examples about the XOR problem", () => {
             },
         ];
 
-        brain.cerebrum.trainMind(trainingPatterns);
+        brain.cerebrum.trainNetwork(trainingPatterns);
         const queryingResults = [] as {
             input: QueryingInputPattern;
             output: QueryingOutputPattern;
         }[];
-        brain.cerebrum.queryMind(
+        brain.cerebrum.queryNetwork(
             queryingPatterns,
             (queryingStatus: QueryingStatus) => {
                 queryingPatterns.forEach(
@@ -123,7 +123,7 @@ describe("When trained with training examples about the XOR problem", () => {
                 );
             },
             undefined,
-            "defaultMind"
+            "defaultNetwork"
         );
 
         expect(queryingResults).toEqual(expectedQueryingResults);