@datagrok-libraries/utils 0.0.4 → 0.0.5

package/src/reduce-dimensionality.ts

@@ -0,0 +1,272 @@
+import * as umj from 'umap-js';
+import {TSNE} from '@keckelt/tsne';
+
+import {Options, DistanceMetric, Coordinates, Vector, Vectors, Matrix} from './type_declarations';
+import {calcDistanceMatrix, transposeMatrix} from './operations';
+import {SPEBase, PSPEBase} from './spe';
+import {Measurer} from './string-measure';
+//import {AlignedSequenceEncoder} from './sequence-encoder';
+
+/**
+ * Abstract dimensionality reducer.
+ *
+ * @abstract
+ * @class Reducer
+ */
+abstract class Reducer {
+  protected data: Vectors;
+
+  /**
+   * Creates an instance of Reducer.
+   * @param {Options} options Options to pass to the constructor.
+   * @memberof Reducer
+   */
+  constructor(options: Options) {
+    this.data = options.data;
+  }
+
+  /**
+   * Is to embed the data given into the two-dimensional space.
+   *
+   * @abstract
+   * @return {Coordinates} Cartesian coordinate of this embedding.
+   * @memberof Reducer
+   */
+  abstract transform(): Coordinates;
+}
+
+/**
+ * Implements t-SNE dimensionality reduction.
+ *
+ * @class TSNEReducer
+ * @extends {Reducer}
+ */
+class TSNEReducer extends Reducer {
+  protected reducer: TSNE;
+  protected iterations: number;
+  protected distance: DistanceMetric;
+
+  /**
+   * Creates an instance of TSNEReducer.
+   * @param {Options} options Options to pass to the constructor.
+   * @memberof TSNEReducer
+   */
+  constructor(options: Options) {
+    super(options);
+    this.reducer = new TSNE(options);
+    this.iterations = options?.iterations ?? 100;
+    this.distance = options.distance;
+  }
+
+  /**
+   * Embeds the data given into the two-dimensional space using t-SNE method.
+   * @return {Coordinates} Cartesian coordinate of this embedding.
+   */
+  public transform(): Coordinates {
+    this.reducer.initDataDist(calcDistanceMatrix(this.data, this.distance));
+
+    for (let i = 0; i < this.iterations; ++i) {
+      this.reducer.step(); // every time you call this, solution gets better
+    }
+    return this.reducer.getSolution();
+  }
+}
+
+/**
+ * Implements UMAP dimensionality reduction.
+ *
+ * @class UMAPReducer
+ * @extends {Reducer}
+ */
+class UMAPReducer extends Reducer {
+  protected reducer: umj.UMAP;
+/*  protected encoder: AlignedSequenceEncoder;
+  protected distanceMatrix: Matrix;*/
+
+  /**
+   * Creates an instance of UMAPReducer.
+   * @param {Options} options Options to pass to the constructor.
+   * @memberof UMAPReducer
+   */
+  constructor(options: Options) {
+    super(options);
+    this.reducer = new umj.UMAP(options);
+/*    this.encoder = new AlignedSequenceEncoder();
+    this.distanceMatrix = calcDistanceMatrix(this.data, options.distanceFn);
+    this.distanceFn = options.distanceFn;*/
+  }
+
+/*  protected _encodedDistance(a: number[], b: number[]): number {
+    return this.distanceMatrix[a[a.length-1]][b[b.length-1]];
+  }
+
+  protected _decodedDistance(a: number[], b: number[]): number {
+    return this.encoder.decode(a);
+  }
+
+  protected encode(): number[][] {
+    let vectors: number[][] = [];
+
+    for (let i = 0; i < this.data.length; ++i) {
+      let encoded = this.encoder.encode(this.data[i]);
+      vectors.push(encoded);
+    }
+    return vectors;
+  }
+
+  protected _calcDistance() {
+    const nItems = this.data.length;
+    const vectors = this.encode();
+    
+  }*/
+
+  /**
+   * Embeds the data given into the two-dimensional space using UMAP method.
+   * @return {Coordinates} Cartesian coordinate of this embedding.
+   */
+  public transform(): Coordinates {
+    const embedding = this.reducer.fit(this.data);
+
+    function arrayCast2Coordinates(data: number[][]): Coordinates {
+      return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));
+    }
+    return arrayCast2Coordinates(embedding);
+  }
+}
+
+/**
+ * Implements original SPE dimensionality reduction.
+ *
+ * @class SPEReducer
+ * @extends {Reducer}
+ */
+class SPEReducer extends Reducer {
+  protected reducer: SPEBase;
+
+  /**
+   * Creates an instance of SPEReducer.
+   * @param {Options} options Options to pass to the constructor.
+   * @memberof SPEReducer
+   */
+  constructor(options: Options) {
+    super(options);
+    this.reducer = new SPEBase(options);
+  }
+
+  /**
+   * Embeds the data given into the two-dimensional space using the original SPE method.
+   * @return {Coordinates} Cartesian coordinate of this embedding.
+   */
+  public transform(): Coordinates {
+    return this.reducer.embed(this.data);
+  }
+}
+
+/**
+ * Implements modified SPE dimensionality reduction.
+ *
+ * @class PSPEReducer
+ * @extends {Reducer}
+ */
+class PSPEReducer extends Reducer {
+  protected reducer: PSPEBase;
+
+  /**
+   * Creates an instance of PSPEReducer.
+   * @param {Options} options Options to pass to the constructor.
+   * @memberof PSPEReducer
+   */
+  constructor(options: Options) {
+    super(options);
+    this.reducer = new PSPEBase(options);
+  }
+
+  /**
+   * Embeds the data given into the two-dimensional space using the modified SPE method.
+   * @return {Coordinates} Cartesian coordinate of this embedding.
+   */
+  public transform(): Coordinates {
+    return this.reducer.embed(this.data);
+  }
+}
+
+/**
+ * Unified class implementing different dimensionality reduction methods.
+ *
+ * @export
+ * @class DimensionalityReducer
+ */
+export class DimensionalityReducer {
+  private reducer: Reducer | undefined;
+  private methods: string[];
+  private measurer: Measurer;
+
+  /**
+   * Creates an instance of DimensionalityReducer.
+   * @param {any[]} data Vectors to embed.
+   * @param {string} method Embedding method to be applied
+   * @param {string} metric Distance metric to be computed between each of the vectors.
+   * @param {Options} [options] Options to pass to the implementing embedders.
+   * @memberof DimensionalityReducer
+   */
+  constructor(data: any[], method: string, metric: string, options?: Options) {
+    this.methods = ['UMAP', 'TSNE', 'SPE', 'PSPE'];
+
+    if (!this.availableMethods.includes(method)) {
+      throw new Error('The method "'+method+'" is not supported');
+    }
+
+    this.measurer = new Measurer(metric);
+    const measure = this.measurer.getMeasure()
+
+    if (method == 'UMAP') {
+      this.reducer = new UMAPReducer({
+        ...{data: data}, 
+        ...{distanceFn: measure}, 
+        ...{nEpochs: options?.cycles},
+        ...options
+      });
+    } else if (method == 'TSNE') {
+      this.reducer = new TSNEReducer({
+        ...{data: data},
+        ...{distance: measure},
+        ...{iterations: options?.cycles ?? undefined},
+        ...options,
+      });
+    } else if (method == 'SPE') {
+      this.reducer = new SPEReducer({...{data: data}, ...{distance: measure}, ...options});
+    } else {
+      this.reducer = new PSPEReducer({...{data: data}, ...{distance: measure}, ...options});
+    }
+  }
+
+  /**
+   * Embeds the data given into the two-dimensional space using the chosen method.
+   *
+   * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.
+   * @throws {Error} If the embedding method was not found.
+   * @return {Coordinates} Cartesian coordinate of this embedding.
+   * @memberof DimensionalityReducer
+   */
+  public transform(transpose: boolean = false): Coordinates {
+    if (this.reducer == undefined) {
+      throw new Error('Reducer was not defined.');
+    }
+    let embedding = this.reducer.transform();
+
+    if (transpose) {
+      embedding = transposeMatrix(embedding);
+    }
+    return embedding;
+  }
+
+  /**
+   * Returns dimensionality reduction methods available.
+   *
+   * @readonly
+   * @memberof DimensionalityReducer
+   */
+  get availableMethods() {
+    return this.methods;
+  }
+}

package/src/sequence-encoder.js

@@ -0,0 +1,116 @@
+import { assert } from './operations';
+/**
+ * Class to categorial encode/decode aligned amino acid residues sequence.
+ *
+ * @export
+ * @class AlignedSequenceEncoder
+ */
+export class AlignedSequenceEncoder {
+    constructor() {
+        this.aa2num = {
+            '-': 0,
+            'A': 1,
+            'C': 2,
+            'D': 3,
+            'E': 4,
+            'F': 5,
+            'G': 6,
+            'H': 7,
+            'I': 8,
+            'K': 9,
+            'L': 10,
+            'M': 11,
+            'N': 12,
+            'P': 13,
+            'Q': 14,
+            'R': 15,
+            'S': 16,
+            'T': 17,
+            'V': 18,
+            'W': 19,
+            'Y': 20,
+        };
+        this.num2aa = {};
+        Object.entries(this.aa2num).forEach(([k, v]) => (this.num2aa[v] = k));
+    }
+    /**
+     * Truncate NH2 and -COOH terminals of the given sequence.
+     *
+     * @protected
+     * @param {string} seq The sequence provided.
+     * @return {string} Truncated sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    _truncateSequence(seq) {
+        let start = 0;
+        let end = seq.length;
+        const termina = ['NH2', 'COOH'];
+        if (seq.startsWith(termina[0])) {
+            const l = termina[0].length; // Cut only 'NH2' without following '-'.
+            assert(seq[l] == '-', `Wrong sequence format: ${termina[0]} without following '-' in '${seq}'.`);
+            start = l;
+        }
+        if (seq.endsWith(termina[1])) {
+            const l = termina[1].length + 1; // Cut both 'COOH' and precending '-'.
+            assert(seq[end - l] == '-', `Wrong sequence format: ${termina[1]} without '-' precending in '${seq}'.`);
+            end -= l;
+        }
+        return seq.substring(start, end);
+    }
+    /**
+     * Cuts auxiliary defises before a residue.
+     *
+     * @protected
+     * @param {string} seq The sequence to process.
+     * @return {string} Processed sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    _dropDefises(seq) {
+        return seq.replace(/(-)([^-]+)/g, '$2');
+    }
+    /**
+     * Performs truncation and cutting auxiliary defises.
+     *
+     * @param {string} sequence The sequence work under process.
+     * @return {string} Result of cleaning.
+     * @memberof AlignedSequenceEncoder
+     */
+    clean(sequence) {
+        return this._dropDefises(this._truncateSequence(sequence));
+    }
+    /**
+     * Categorial encode of the sequence provided.
+     *
+     * @param {string} sequence The sequence.
+     * @return {number[]} Encoded vector.
+     * @memberof AlignedSequenceEncoder
+     */
+    encode(sequence) {
+        const seq = this.clean(sequence);
+        const nItems = seq.length;
+        let values = new Array(nItems).fill(0);
+        for (let i = 0; i < nItems; ++i) {
+            let char = seq[i];
+            assert(char in this.aa2num, `Unknown char '${char}' found in sequence '${seq}'`);
+            values[i] = this.aa2num[char];
+        }
+        return values;
+    }
+    /**
+     * Decode the encoded vector into the sequence back.
+     *
+     * @param {number[]} value The vector encoded.
+     * @return {string} Decoded sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    decode(value) {
+        let s = '';
+        for (let i = 0; i < value.length; ++i) {
+            let code = value[i];
+            assert(code in this.num2aa, `Unknown code '${code}' found in vector '${value}'`);
+            s += this.num2aa[code];
+        }
+        return s;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequence-encoder.js","sourceRoot":"","sources":["sequence-encoder.ts"],"names":[],"mappings":"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","sourcesContent":["import {assert} from './operations';\r\n\r\n/**\r\n * Class to categorial encode/decode aligned amino acid residues sequence.\r\n *\r\n * @export\r\n * @class AlignedSequenceEncoder\r\n */\r\nexport class AlignedSequenceEncoder {\r\n    protected aa2num: {[name: string]: number};\r\n    protected num2aa: {[code: number]: string};\r\n\r\n    constructor () {\r\n        this.aa2num = {\r\n            '-': 0,\r\n            'A': 1,\r\n            'C': 2,\r\n            'D': 3,\r\n            'E': 4,\r\n            'F': 5,\r\n            'G': 6,\r\n            'H': 7,\r\n            'I': 8,\r\n            'K': 9,\r\n            'L': 10,\r\n            'M': 11,\r\n            'N': 12,\r\n            'P': 13,\r\n            'Q': 14,\r\n            'R': 15,\r\n            'S': 16,\r\n            'T': 17,\r\n            'V': 18,\r\n            'W': 19,\r\n            'Y': 20,\r\n        };\r\n        this.num2aa = {};\r\n        Object.entries(this.aa2num).forEach(([k, v]) => (this.num2aa[v] = k));\r\n    }\r\n\r\n    /**\r\n     * Truncate NH2 and -COOH terminals of the given sequence.\r\n     *\r\n     * @protected\r\n     * @param {string} seq The sequence provided.\r\n     * @return {string} Truncated sequence.\r\n     * @memberof AlignedSequenceEncoder\r\n     */\r\n    protected _truncateSequence(seq: string): string {\r\n        let start = 0;\r\n        let end = seq.length;\r\n        const termina = ['NH2', 'COOH'];\r\n    \r\n        if (seq.startsWith(termina[0])) {\r\n            const l = termina[0].length; // Cut only 'NH2' without following '-'.\r\n            assert(seq[l] == '-', `Wrong sequence format: ${termina[0]} without following '-' in '${seq}'.`)\r\n            start = l;\r\n        }\r\n        if (seq.endsWith(termina[1])) {\r\n            const l = termina[1].length+1; // Cut both 'COOH' and precending '-'.\r\n            assert(seq[end-l] == '-', `Wrong sequence format: ${termina[1]} without '-' precending in '${seq}'.`)\r\n            end -= l;\r\n        }\r\n        return seq.substring(start, end);\r\n    }\r\n\r\n    /**\r\n     * Cuts auxiliary defises before a residue.\r\n     *\r\n     * @protected\r\n     * @param {string} seq The sequence to process.\r\n     * @return {string} Processed sequence.\r\n     * @memberof AlignedSequenceEncoder\r\n     */\r\n    protected _dropDefises(seq: string): string {\r\n        return seq.replace(/(-)([^-]+)/g, '$2')\r\n    }\r\n\r\n    /**\r\n     * Performs truncation and cutting auxiliary defises.\r\n     *\r\n     * @param {string} sequence The sequence work under process.\r\n     * @return {string} Result of cleaning.\r\n     * @memberof AlignedSequenceEncoder\r\n     */\r\n    public clean(sequence: string): string {\r\n        return this._dropDefises(this._truncateSequence(sequence));\r\n    }\r\n\r\n    /**\r\n     * Categorial encode of the sequence provided.\r\n     *\r\n     * @param {string} sequence The sequence.\r\n     * @return {number[]} Encoded vector.\r\n     * @memberof AlignedSequenceEncoder\r\n     */\r\n    public encode(sequence: string): number[] {\r\n        const seq = this.clean(sequence);\r\n        const nItems = seq.length;\r\n        let values = new Array(nItems).fill(0);\r\n    \r\n        for (let i = 0; i < nItems; ++i) {\r\n            let char = seq[i];\r\n    \r\n            assert(char in this.aa2num, `Unknown char '${char}' found in sequence '${seq}'`);\r\n    \r\n            values[i] = this.aa2num[char];\r\n        }\r\n        return values;\r\n    }\r\n\r\n    /**\r\n     * Decode the encoded vector into the sequence back.\r\n     *\r\n     * @param {number[]} value The vector encoded.\r\n     * @return {string} Decoded sequence.\r\n     * @memberof AlignedSequenceEncoder\r\n     */\r\n    public decode(value: number[]): string {\r\n        let s: string = '';\r\n    \r\n        for (let i = 0; i < value.length; ++i) {\r\n            let code = value[i];\r\n\r\n            assert(code in this.num2aa, `Unknown code '${code}' found in vector '${value}'`);\r\n\r\n            s += this.num2aa[code];\r\n        }\r\n        return s;\r\n    }\r\n}\r\n"]}

package/src/sequence-encoder.ts

@@ -0,0 +1,131 @@
+import {assert} from './operations';
+
+/**
+ * Class to categorial encode/decode aligned amino acid residues sequence.
+ *
+ * @export
+ * @class AlignedSequenceEncoder
+ */
+export class AlignedSequenceEncoder {
+    protected aa2num: {[name: string]: number};
+    protected num2aa: {[code: number]: string};
+
+    constructor () {
+        this.aa2num = {
+            '-': 0,
+            'A': 1,
+            'C': 2,
+            'D': 3,
+            'E': 4,
+            'F': 5,
+            'G': 6,
+            'H': 7,
+            'I': 8,
+            'K': 9,
+            'L': 10,
+            'M': 11,
+            'N': 12,
+            'P': 13,
+            'Q': 14,
+            'R': 15,
+            'S': 16,
+            'T': 17,
+            'V': 18,
+            'W': 19,
+            'Y': 20,
+        };
+        this.num2aa = {};
+        Object.entries(this.aa2num).forEach(([k, v]) => (this.num2aa[v] = k));
+    }
+
+    /**
+     * Truncate NH2 and -COOH terminals of the given sequence.
+     *
+     * @protected
+     * @param {string} seq The sequence provided.
+     * @return {string} Truncated sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    protected _truncateSequence(seq: string): string {
+        let start = 0;
+        let end = seq.length;
+        const termina = ['NH2', 'COOH'];
+    
+        if (seq.startsWith(termina[0])) {
+            const l = termina[0].length; // Cut only 'NH2' without following '-'.
+            assert(seq[l] == '-', `Wrong sequence format: ${termina[0]} without following '-' in '${seq}'.`)
+            start = l;
+        }
+        if (seq.endsWith(termina[1])) {
+            const l = termina[1].length+1; // Cut both 'COOH' and precending '-'.
+            assert(seq[end-l] == '-', `Wrong sequence format: ${termina[1]} without '-' precending in '${seq}'.`)
+            end -= l;
+        }
+        return seq.substring(start, end);
+    }
+
+    /**
+     * Cuts auxiliary defises before a residue.
+     *
+     * @protected
+     * @param {string} seq The sequence to process.
+     * @return {string} Processed sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    protected _dropDefises(seq: string): string {
+        return seq.replace(/(-)([^-]+)/g, '$2')
+    }
+
+    /**
+     * Performs truncation and cutting auxiliary defises.
+     *
+     * @param {string} sequence The sequence work under process.
+     * @return {string} Result of cleaning.
+     * @memberof AlignedSequenceEncoder
+     */
+    public clean(sequence: string): string {
+        return this._dropDefises(this._truncateSequence(sequence));
+    }
+
+    /**
+     * Categorial encode of the sequence provided.
+     *
+     * @param {string} sequence The sequence.
+     * @return {number[]} Encoded vector.
+     * @memberof AlignedSequenceEncoder
+     */
+    public encode(sequence: string): number[] {
+        const seq = this.clean(sequence);
+        const nItems = seq.length;
+        let values = new Array(nItems).fill(0);
+    
+        for (let i = 0; i < nItems; ++i) {
+            let char = seq[i];
+    
+            assert(char in this.aa2num, `Unknown char '${char}' found in sequence '${seq}'`);
+    
+            values[i] = this.aa2num[char];
+        }
+        return values;
+    }
+
+    /**
+     * Decode the encoded vector into the sequence back.
+     *
+     * @param {number[]} value The vector encoded.
+     * @return {string} Decoded sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    public decode(value: number[]): string {
+        let s: string = '';
+    
+        for (let i = 0; i < value.length; ++i) {
+            let code = value[i];
+
+            assert(code in this.num2aa, `Unknown code '${code}' found in vector '${value}'`);
+
+            s += this.num2aa[code];
+        }
+        return s;
+    }
+}