recurrent-js-gpu/dist/Graph.js

GPU-accelerated Deep Recurrent Neural Networks and LSTMs in Typescript. Ported, object-oriented and refactored version of Andrej Karpathy's recurrent-js (https://github.com/karpathy/recurrentjs)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Assertable_1 = require("./utils/Assertable");
const Mat_1 = require("./Mat");
class Graph extends Assertable_1.Assertable {
    constructor(needsBackprop = true) {
        super();
        this.needsBackprop = needsBackprop;
        this.backprop = new Array();
    }
    backward() {
        for (let i = this.backprop.length - 1; i >= 0; i--) {
            this.backprop[i]();
        }
    }
    rowPluck(m, ix) {
        const out = Mat_1.Mat.rowPluck(m, ix);
        this.addRowPluckToBackprop(m, ix, out);
        return out;
    }
    addRowPluckToBackprop(m, ix, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m.cols; i++) {
                    m.dw[m.cols * ix + i] += out.dw[i];
                }
            };
            this.backprop.push(backward);
        }
    }
    tanh(m) {
        const out = Mat_1.Mat.tanh(m);
        this.addTanhToBackprop(m, out);
        return out;
    }
    addTanhToBackprop(m, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m.w.length; i++) {
                    const mwi = out.w[i];
                    m.dw[i] += (1.0 - mwi * mwi) * out.dw[i];
                }
            };
            this.backprop.push(backward);
        }
    }
    sigmoid(m) {
        const out = Mat_1.Mat.sig(m);
        this.addSigmoidToBackprop(m, out);
        return out;
    }
    addSigmoidToBackprop(m, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m.w.length; i++) {
                    const mwi = out.w[i];
                    m.dw[i] += mwi * (1.0 - mwi) * out.dw[i];
                }
            };
            this.backprop.push(backward);
        }
    }
    relu(m) {
        const out = Mat_1.Mat.relu(m);
        this.addReluToBackprop(m, out);
        return out;
    }
    addReluToBackprop(m, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m.w.length; i++) {
                    m.dw[i] += m.w[i] > 0 ? out.dw[i] : 0.0;
                }
            };
            this.backprop.push(backward);
        }
    }
    mul(m1, m2) {
        const out = Mat_1.Mat.mul(m1, m2);
        this.addMultiplyToBackprop(m1, m2, out);
        return out;
    }
    addMultiplyToBackprop(m1, m2, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m1.rows; i++) {
                    for (let j = 0; j < m2.cols; j++) {
                        for (let k = 0; k < m1.cols; k++) {
                            const b = out.dw[m2.cols * i + j];
                            m1.dw[m1.cols * i + k] += m2.w[m2.cols * k + j] * b;
                            m2.dw[m2.cols * k + j] += m1.w[m1.cols * i + k] * b;
                        }
                    }
                }
            };
            this.backprop.push(backward);
        }
    }
    add(m1, m2) {
        const out = Mat_1.Mat.add(m1, m2);
        this.addAdditionToBackprop(m1, m2, out);
        return out;
    }
    addAdditionToBackprop(m1, m2, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m1.w.length; i++) {
                    m1.dw[i] += out.dw[i];
                    m2.dw[i] += out.dw[i];
                }
            };
            this.backprop.push(backward);
        }
    }
    dot(m1, m2) {
        const out = Mat_1.Mat.dot(m1, m2);
        this.addDotToBackprop(m1, m2, out);
        return out;
    }
    addDotToBackprop(m1, m2, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m1.w.length; i++) {
                    m1.dw[i] += m2.w[i] * out.dw[0];
                    m2.dw[i] += m1.w[i] * out.dw[0];
                }
            };
            this.backprop.push(backward);
        }
    }
    eltmul(m1, m2) {
        const out = Mat_1.Mat.eltmul(m1, m2);
        this.addEltmulToBackprop(m1, m2, out);
        return out;
    }
    addEltmulToBackprop(m1, m2, out) {
        if (this.needsBackprop) {
            const backward = () => {
                for (let i = 0; i < m1.w.length; i++) {
                    m1.dw[i] += m2.w[i] * out.dw[i];
                    m2.dw[i] += m1.w[i] * out.dw[i];
                }
            };
            this.backprop.push(backward);
        }
    }
}
exports.Graph = Graph;
//# sourceMappingURL=Graph.js.map