@reicek/neataptic-ts 0.1.0

package/src/multithreading/workers/browser/testworker.ts

@@ -0,0 +1,99 @@
+import Multi from '../../multi';
+
+/**
+ * TestWorker class for handling network evaluations in a browser environment using Web Workers.
+ *
+ * This implementation aligns with the Instinct algorithm's emphasis on efficient evaluation of
+ * neural networks in parallel environments. The use of Web Workers allows for offloading
+ * computationally expensive tasks, such as network evaluation, to separate threads.
+ *
+ * @see Instinct Algorithm - Section 4 Constraints
+ * @see {@link https://medium.com/data-science/neuro-evolution-on-steroids-82bd14ddc2f6}
+ */
+export class TestWorker {
+  private worker: Worker;
+  private url: string;
+
+  /**
+   * Creates a new TestWorker instance.
+   * @param {number[]} dataSet - The serialized dataset to be used by the worker.
+   * @param {any} cost - The cost function to evaluate the network.
+   */
+  constructor(dataSet: number[], cost: { name: string }) {
+    const blob = new Blob([TestWorker._createBlobString(cost)]);
+    this.url = window.URL.createObjectURL(blob);
+    this.worker = new Worker(this.url);
+
+    const data = { set: new Float64Array(dataSet).buffer };
+    this.worker.postMessage(data, [data.set]);
+  }
+
+  /**
+   * Evaluates a network using the worker process.
+   * @param {any} network - The network to evaluate.
+   * @returns {Promise<number>} A promise that resolves to the evaluation result.
+   */
+  evaluate(network: any): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const serialized = network.serialize();
+
+      const data = {
+        activations: new Float64Array(serialized[0]).buffer,
+        states: new Float64Array(serialized[1]).buffer,
+        conns: new Float64Array(serialized[2]).buffer,
+      };
+
+      this.worker.onmessage = function (e: MessageEvent) {
+        const error = new Float64Array(e.data.buffer)[0];
+        resolve(error);
+      };
+
+      this.worker.postMessage(data, [
+        data.activations,
+        data.states,
+        data.conns,
+      ]);
+    });
+  }
+
+  /**
+   * Terminates the worker process and revokes the object URL.
+   */
+  terminate(): void {
+    this.worker.terminate();
+    window.URL.revokeObjectURL(this.url);
+  }
+
+  /**
+   * Creates a string representation of the worker's blob.
+   * @param {any} cost - The cost function to be used by the worker.
+   * @returns {string} The blob string.
+   */
+  private static _createBlobString(cost: any): string {
+    return `
+      const F = [${Multi.activations.toString()}];
+      const cost = ${cost.toString()};
+      const multi = {
+        deserializeDataSet: ${Multi.deserializeDataSet.toString()},
+        testSerializedSet: ${Multi.testSerializedSet.toString()},
+        activateSerializedNetwork: ${Multi.activateSerializedNetwork.toString()}
+      };
+
+      let set;
+
+      this.onmessage = function (e) {
+        if (typeof e.data.set === 'undefined') {
+          const A = new Float64Array(e.data.activations);
+          const S = new Float64Array(e.data.states);
+          const data = new Float64Array(e.data.conns);
+
+          const error = multi.testSerializedSet(set, cost, A, S, data, F);
+
+          const answer = { buffer: new Float64Array([error]).buffer };
+          postMessage(answer, [answer.buffer]);
+        } else {
+          set = multi.deserializeDataSet(new Float64Array(e.data.set));
+        }
+      };`;
+  }
+}

package/src/multithreading/workers/node/README.md

@@ -0,0 +1,33 @@
+# multithreading/workers/node
+
+## multithreading/workers/node/testworker.ts
+
+### TestWorker
+
+TestWorker class for handling network evaluations in a Node.js environment using Worker Threads.
+
+This implementation aligns with the Instinct algorithm's emphasis on efficient evaluation of
+neural networks in parallel environments. The use of Worker Threads allows for offloading
+computationally expensive tasks, such as network evaluation, to separate threads.
+
+#### evaluate
+
+`(network: any) => Promise<number>`
+
+Evaluates a neural network using the worker process.
+
+The network is serialized and sent to the worker for evaluation. The worker
+sends back the evaluation result, which is returned as a promise.
+
+Parameters:
+- `` - - The neural network to evaluate. It must implement a `serialize` method.
+
+Returns: A promise that resolves to the evaluation result.
+
+#### terminate
+
+`() => void`
+
+Terminates the worker process.
+
+This method ensures that the worker process is properly terminated to free up system resources.

package/src/multithreading/workers/node/testworker.ts

@@ -0,0 +1,72 @@
+import { fork, ChildProcess } from 'child_process';
+import path from 'path';
+
+/**
+ * TestWorker class for handling network evaluations in a Node.js environment using Worker Threads.
+ *
+ * This implementation aligns with the Instinct algorithm's emphasis on efficient evaluation of
+ * neural networks in parallel environments. The use of Worker Threads allows for offloading
+ * computationally expensive tasks, such as network evaluation, to separate threads.
+ *
+ * @see {@link https://medium.com/data-science/neuro-evolution-on-steroids-82bd14ddc2f6#4-constraints Instinct Algorithm - Section 4 Constraints}
+ *
+ * This class provides methods to evaluate neural networks and manage the worker process.
+ */
+export class TestWorker {
+  private worker: ChildProcess;
+
+  /**
+   * Creates a new TestWorker instance.
+   *
+   * This initializes a new worker process and sends the dataset and cost function
+   * to the worker for further processing.
+   *
+   * @param {number[]} dataSet - The serialized dataset to be used by the worker.
+   * @param {{ name: string }} cost - The cost function to evaluate the network.
+   */
+  constructor(dataSet: number[], cost: { name: string }) {
+    this.worker = fork(path.join(__dirname, '/worker'));
+    this.worker.send({ set: dataSet, cost: cost.name });
+  }
+
+  /**
+   * Evaluates a neural network using the worker process.
+   *
+   * The network is serialized and sent to the worker for evaluation. The worker
+   * sends back the evaluation result, which is returned as a promise.
+   *
+   * @param {any} network - The neural network to evaluate. It must implement a `serialize` method.
+   * @returns {Promise<number>} A promise that resolves to the evaluation result.
+   */
+  evaluate(network: any): Promise<number> {
+    return new Promise((resolve) => {
+      const serialized = network.serialize();
+
+      const data = {
+        activations: serialized[0],
+        states: serialized[1],
+        conns: serialized[2],
+      };
+
+      const _that = this.worker;
+      this.worker.on('message', function callback(e: number) {
+        _that.removeListener('message', callback);
+        resolve(e);
+      });
+
+      this.worker.send(data);
+    });
+  }
+
+  /**
+   * Terminates the worker process.
+   *
+   * This method ensures that the worker process is properly terminated to free up system resources.
+   */
+  terminate(): void {
+    this.worker.kill();
+  }
+}
+
+// Add default export to match the original JavaScript implementation.
+export default TestWorker;

package/src/multithreading/workers/node/worker.ts

@@ -0,0 +1,70 @@
+import Multi from '../../../multithreading/multi';
+import * as methods from '../../../methods/methods';
+
+/**
+ * The dataset to be used by the worker.
+ * This is an array of objects where each object contains:
+ * - `input`: An array of input values for the network.
+ * - `output`: An array of expected output values for the network.
+ */
+let set: Array<{ input: number[]; output: number[] }> = [];
+
+/**
+ * The cost function to evaluate the network's performance.
+ * It takes the expected and actual output arrays and returns a numerical cost value.
+ */
+let cost: (expected: number[], actual: number[]) => number;
+
+/**
+ * The activation functions to be used by the worker.
+ * These are imported from the `Multi` module.
+ */
+const F = Multi.activations;
+
+/**
+ * Handles messages sent to the worker process.
+ *
+ * This function listens for messages sent to the worker process and performs one of two actions:
+ * 1. If the message contains serialized activations, states, and connections, it evaluates the network using the dataset.
+ * 2. If the message contains a dataset and cost function, it initializes the worker with the provided data.
+ *
+ * @param e - The message object sent to the worker process. It can contain:
+ *   - `set`: Serialized dataset to initialize the worker. This is an array of objects with `input` and `output` properties.
+ *   - `cost`: The name of the cost function to use. This should match a key in the `methods.Cost` object.
+ *   - `activations`: Serialized activation values for the network.
+ *   - `states`: Serialized state values for the network.
+ *   - `conns`: Serialized connection data for the network.
+ */
+process.on(
+  'message',
+  (e: {
+    set?: any;
+    cost?: string;
+    activations?: any;
+    states?: any;
+    conns?: any;
+  }) => {
+    if (typeof e.set === 'undefined') {
+      // Deserialize the activations, states, and connections from the message
+      const { activations: A, states: S, conns: data } = e;
+
+      // Evaluate the network using the serialized dataset and send the result back
+      const result = Multi.testSerializedSet(set, cost, A, S, data, F);
+
+      // Send the evaluation result back to the parent process
+      if (process.send) {
+        process.send(result);
+      }
+    } else {
+      // Initialize the cost function using the provided name
+      // The cost function is retrieved from the `methods.Cost` object
+      cost = methods.Cost[e.cost as keyof typeof methods.Cost] as (
+        expected: number[],
+        actual: number[]
+      ) => number;
+
+      // Deserialize the dataset from the message and store it in the `set` variable
+      set = Multi.deserializeDataSet(e.set);
+    }
+  }
+);

package/src/multithreading/workers/workers.ts

@@ -0,0 +1,22 @@
+/**
+ * Utility class for managing workers in both Node.js and browser environments.
+ */
+export class Workers {
+  /**
+   * Loads the Node.js test worker dynamically.
+   * @returns {Promise<any>} A promise that resolves to the Node.js TestWorker class.
+   */
+  static async getNodeTestWorker(): Promise<any> {
+    const module = await import('./node/testworker');
+    return module.TestWorker;
+  }
+
+  /**
+   * Loads the browser test worker dynamically.
+   * @returns {Promise<any>} A promise that resolves to the browser TestWorker class.
+   */
+  static async getBrowserTestWorker(): Promise<any> {
+    const module = await import('./browser/testworker');
+    return module.TestWorker;
+  }
+}