@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-layers/dist/layers/advanced_activations.js

@@ -0,0 +1,184 @@
+import "../../../tfjs-core/dist/index.js";
+import { Softmax as L } from "../activations.js";
+import { getConstraint as g, serializeConstraint as C } from "../constraints.js";
+import { Layer as i, InputSpec as E } from "../engine/topology.js";
+import { ValueError as U, NotImplementedError as b } from "../errors.js";
+import { getInitializer as T, serializeInitializer as I } from "../initializers.js";
+import { getRegularizer as y, serializeRegularizer as z } from "../regularizers.js";
+import { getExactlyOneTensor as r, getExactlyOneShape as R } from "../utils/types_utils.js";
+import { leakyRelu as O } from "../../../tfjs-core/dist/ops/leaky_relu.js";
+import { prelu as _ } from "../../../tfjs-core/dist/ops/prelu.js";
+import { logSumExp as k } from "../../../tfjs-core/dist/ops/log_sum_exp.js";
+import { registerClass as l } from "../../../tfjs-core/dist/serialization.js";
+import { relu as w } from "../../../tfjs-core/dist/ops/relu.js";
+import { clipByValue as D } from "../../../tfjs-core/dist/ops/clip_by_value.js";
+import { elu as F } from "../../../tfjs-core/dist/ops/elu.js";
+import { mul as h } from "../../../tfjs-core/dist/ops/mul.js";
+import { cast as u } from "../../../tfjs-core/dist/ops/cast.js";
+import { greater as S } from "../../../tfjs-core/dist/ops/greater.js";
+import { tidy as N } from "../../../tfjs-core/dist/globals.js";
+import { sub as n } from "../../../tfjs-core/dist/ops/sub.js";
+import { ones as H } from "../../../tfjs-core/dist/ops/ones.js";
+import { scalar as P } from "../../../tfjs-core/dist/ops/scalar.js";
+import { add as V } from "../../../tfjs-core/dist/ops/add.js";
+import { exp as j } from "../../../tfjs-core/dist/ops/exp.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+class p extends i {
+  constructor(t) {
+    super(t ?? {}), this.supportsMasking = !0, t != null && (this.maxValue = t.maxValue);
+  }
+  call(t, s) {
+    t = r(t);
+    let e = w(t);
+    return this.maxValue != null && (e = D(e, 0, this.maxValue)), e;
+  }
+  computeOutputShape(t) {
+    return t;
+  }
+  getConfig() {
+    const t = { maxValue: this.maxValue }, s = super.getConfig();
+    return Object.assign(t, s), t;
+  }
+}
+p.className = "ReLU";
+l(p);
+class m extends i {
+  constructor(t) {
+    super(t ?? {}), this.DEFAULT_ALPHA = 0.3, t == null && (t = {}), this.alpha = t.alpha == null ? this.DEFAULT_ALPHA : t.alpha;
+  }
+  call(t, s) {
+    const e = r(t);
+    return O(e, this.alpha);
+  }
+  computeOutputShape(t) {
+    return t;
+  }
+  getConfig() {
+    const t = { alpha: this.alpha }, s = super.getConfig();
+    return Object.assign(t, s), t;
+  }
+}
+m.className = "LeakyReLU";
+l(m);
+class f extends i {
+  constructor(t) {
+    if (super(t ?? {}), this.DEFAULT_ALPHA_INITIALIZER = "zeros", t == null && (t = {}), this.supportsMasking = !0, this.alphaInitializer = T(t.alphaInitializer || this.DEFAULT_ALPHA_INITIALIZER), this.alphaRegularizer = y(t.alphaRegularizer), this.alphaConstraint = g(t.alphaConstraint), t.sharedAxes == null)
+      this.sharedAxes = null;
+    else if (Array.isArray(t.sharedAxes))
+      this.sharedAxes = t.sharedAxes;
+    else if (typeof t.sharedAxes == "number")
+      this.sharedAxes = [t.sharedAxes];
+    else
+      throw new U(`Expected sharedAxes to be a number or an array of numbers, but got ${t.sharedAxes}`);
+  }
+  build(t) {
+    t = R(t);
+    const s = t.slice(1);
+    if (this.sharedAxes != null)
+      for (const a of this.sharedAxes)
+        s[a - 1] = 1;
+    this.alpha = this.addWeight("alpha", s, "float32", this.alphaInitializer, this.alphaRegularizer, !0, this.alphaConstraint);
+    const e = {};
+    if (this.sharedAxes != null)
+      for (let a = 1; a < t.length; ++a)
+        e[a] = t[a];
+    this.inputSpec = [new E({
+      ndim: t.length,
+      axes: e
+    })], this.built = !0;
+  }
+  call(t, s) {
+    return t = r(t), _(t, this.alpha.read());
+  }
+  getConfig() {
+    const t = {
+      alphaInitializer: I(this.alphaInitializer),
+      alphaRegularizer: z(this.alphaRegularizer),
+      alphaConstraint: C(this.alphaConstraint),
+      sharedAxes: this.sharedAxes
+    }, s = super.getConfig();
+    return Object.assign(t, s), t;
+  }
+}
+f.className = "PReLU";
+l(f);
+class c extends i {
+  constructor(t) {
+    if (super(t ?? {}), this.DEFAULT_ALPHA = 1, t == null && (t = {}), t.alpha != null && t.alpha !== this.DEFAULT_ALPHA)
+      throw new b(`Non-default alpha value (${t.alpha}) is not supported by the ELU layer yet.`);
+    this.alpha = t.alpha == null ? this.DEFAULT_ALPHA : t.alpha;
+  }
+  call(t, s) {
+    const e = r(t);
+    return F(e);
+  }
+  computeOutputShape(t) {
+    return t;
+  }
+  getConfig() {
+    const t = { alpha: this.alpha }, s = super.getConfig();
+    return Object.assign(t, s), t;
+  }
+}
+c.className = "ELU";
+l(c);
+class x extends i {
+  constructor(t) {
+    super(t ?? {}), this.DEFAULT_THETA = 1, t == null && (t = {}), this.theta = t.theta == null ? this.DEFAULT_THETA : t.theta;
+  }
+  call(t, s) {
+    const e = r(t);
+    return h(e, u(S(e, this.theta), "float32"));
+  }
+  computeOutputShape(t) {
+    return t;
+  }
+  getConfig() {
+    const t = { theta: this.theta }, s = super.getConfig();
+    return Object.assign(t, s), t;
+  }
+}
+x.className = "ThresholdedReLU";
+l(x);
+class A extends i {
+  constructor(t) {
+    super(t ?? {}), this.DEFAULT_AXIS = 1, t == null && (t = {}), this.softmax = new L().apply, this.axis = t.axis == null ? this.DEFAULT_AXIS : t.axis;
+  }
+  call(t, s) {
+    return N(() => {
+      let e = r(t);
+      const a = s.mask;
+      if (a != null) {
+        const d = h(n(H(e.shape), u(a, e.dtype)), P(-1e9));
+        e = V(e, d);
+      }
+      return this.axis instanceof Array ? this.axis.length > 1 ? j(n(e, k(e, this.axis, !0))) : this.softmax(e, this.axis[0]) : this.softmax(e, this.axis);
+    });
+  }
+  computeOutputShape(t) {
+    return t;
+  }
+  getConfig() {
+    const t = { axis: this.axis }, s = super.getConfig();
+    return Object.assign(t, s), t;
+  }
+}
+A.className = "Softmax";
+l(A);
+export {
+  c as ELU,
+  m as LeakyReLU,
+  f as PReLU,
+  p as ReLU,
+  A as Softmax,
+  x as ThresholdedReLU
+};
+//# sourceMappingURL=advanced_activations.js.map

package/dist/node_modules/@tensorflow/tfjs-layers/dist/layers/advanced_activations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced_activations.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-layers/dist/layers/advanced_activations.js"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Use of this source code is governed by an MIT-style\n * license that can be found in the LICENSE file or at\n * https://opensource.org/licenses/MIT.\n * =============================================================================\n */\n/**\n *  Advanced activation layers.\n */\nimport { add, cast, clipByValue, elu, exp, greater, leakyRelu, logSumExp, mul, ones, prelu, relu, scalar, serialization, sub, tidy } from '@tensorflow/tfjs-core';\nimport { Softmax as softmaxActivation } from '../activations';\nimport { getConstraint, serializeConstraint } from '../constraints';\nimport { InputSpec, Layer } from '../engine/topology';\nimport { NotImplementedError, ValueError } from '../errors';\nimport { getInitializer, serializeInitializer } from '../initializers';\nimport { getRegularizer, serializeRegularizer } from '../regularizers';\nimport { getExactlyOneShape, getExactlyOneTensor } from '../utils/types_utils';\nclass ReLU extends Layer {\n    constructor(args) {\n        super(args == null ? {} : args);\n        this.supportsMasking = true;\n        if (args != null) {\n            this.maxValue = args.maxValue;\n        }\n    }\n    call(inputs, kwargs) {\n        inputs = getExactlyOneTensor(inputs);\n        let output = relu(inputs);\n        if (this.maxValue != null) {\n            output = clipByValue(output, 0, this.maxValue);\n        }\n        return output;\n    }\n    computeOutputShape(inputShape) {\n        return inputShape;\n    }\n    getConfig() {\n        const config = { maxValue: this.maxValue };\n        const baseConfig = super.getConfig();\n        Object.assign(config, baseConfig);\n        return config;\n    }\n}\n/** @nocollapse */\nReLU.className = 'ReLU';\nexport { ReLU };\nserialization.registerClass(ReLU);\nclass LeakyReLU extends Layer {\n    constructor(args) {\n        super(args == null ? {} : args);\n        this.DEFAULT_ALPHA = 0.3;\n        if (args == null) {\n            args = {};\n        }\n        this.alpha = args.alpha == null ? this.DEFAULT_ALPHA : args.alpha;\n    }\n    call(inputs, kwargs) {\n        const x = getExactlyOneTensor(inputs);\n        return leakyRelu(x, this.alpha);\n    }\n    computeOutputShape(inputShape) {\n        return inputShape;\n    }\n    getConfig() {\n        const config = { alpha: this.alpha };\n        const baseConfig = super.getConfig();\n        Object.assign(config, baseConfig);\n        return config;\n    }\n}\n/** @nocollapse */\nLeakyReLU.className = 'LeakyReLU';\nexport { LeakyReLU };\nserialization.registerClass(LeakyReLU);\nclass PReLU extends Layer {\n    constructor(args) {\n        super(args == null ? {} : args);\n        this.DEFAULT_ALPHA_INITIALIZER = 'zeros';\n        if (args == null) {\n            args = {};\n        }\n        this.supportsMasking = true;\n        this.alphaInitializer =\n            getInitializer(args.alphaInitializer || this.DEFAULT_ALPHA_INITIALIZER);\n        this.alphaRegularizer = getRegularizer(args.alphaRegularizer);\n        this.alphaConstraint = getConstraint(args.alphaConstraint);\n        if (args.sharedAxes == null) {\n            this.sharedAxes = null;\n        }\n        else if (Array.isArray(args.sharedAxes)) {\n            this.sharedAxes = args.sharedAxes;\n        }\n        else if (typeof args.sharedAxes === 'number') {\n            this.sharedAxes = [args.sharedAxes];\n        }\n        else {\n            throw new ValueError(`Expected sharedAxes to be a number or an array of numbers, ` +\n                `but got ${args.sharedAxes}`);\n        }\n    }\n    build(inputShape) {\n        inputShape = getExactlyOneShape(inputShape);\n        const paramShape = inputShape.slice(1);\n        if (this.sharedAxes != null) {\n            for (const i of this.sharedAxes) {\n                paramShape[i - 1] = 1;\n            }\n        }\n        this.alpha = this.addWeight('alpha', paramShape, 'float32', this.alphaInitializer, this.alphaRegularizer, true, this.alphaConstraint);\n        // Set input spec.\n        const axes = {};\n        if (this.sharedAxes != null) {\n            for (let i = 1; i < inputShape.length; ++i) {\n                axes[i] = inputShape[i];\n            }\n        }\n        this.inputSpec = [new InputSpec({\n                ndim: inputShape.length,\n                axes,\n            })];\n        this.built = true;\n    }\n    call(inputs, kwargs) {\n        inputs = getExactlyOneTensor(inputs);\n        return prelu(inputs, this.alpha.read());\n    }\n    getConfig() {\n        const config = {\n            alphaInitializer: serializeInitializer(this.alphaInitializer),\n            alphaRegularizer: serializeRegularizer(this.alphaRegularizer),\n            alphaConstraint: serializeConstraint(this.alphaConstraint),\n            sharedAxes: this.sharedAxes\n        };\n        const baseConfig = super.getConfig();\n        Object.assign(config, baseConfig);\n        return config;\n    }\n}\n/** @nocollapse */\nPReLU.className = 'PReLU';\nexport { PReLU };\nserialization.registerClass(PReLU);\nclass ELU extends Layer {\n    constructor(args) {\n        super(args == null ? {} : args);\n        this.DEFAULT_ALPHA = 1.0;\n        if (args == null) {\n            args = {};\n        }\n        if (args.alpha != null && args.alpha !== this.DEFAULT_ALPHA) {\n            throw new NotImplementedError(`Non-default alpha value (${args.alpha}) is not supported by the ` +\n                `ELU layer yet.`);\n        }\n        this.alpha = args.alpha == null ? this.DEFAULT_ALPHA : args.alpha;\n    }\n    call(inputs, kwargs) {\n        const x = getExactlyOneTensor(inputs);\n        return elu(x);\n    }\n    computeOutputShape(inputShape) {\n        return inputShape;\n    }\n    getConfig() {\n        const config = { alpha: this.alpha };\n        const baseConfig = super.getConfig();\n        Object.assign(config, baseConfig);\n        return config;\n    }\n}\n/** @nocollapse */\nELU.className = 'ELU';\nexport { ELU };\nserialization.registerClass(ELU);\nclass ThresholdedReLU extends Layer {\n    constructor(args) {\n        super(args == null ? {} : args);\n        this.DEFAULT_THETA = 1.0;\n        if (args == null) {\n            args = {};\n        }\n        this.theta = args.theta == null ? this.DEFAULT_THETA : args.theta;\n    }\n    call(inputs, kwargs) {\n        const x = getExactlyOneTensor(inputs);\n        return mul(x, cast(greater(x, this.theta), 'float32'));\n    }\n    computeOutputShape(inputShape) {\n        return inputShape;\n    }\n    getConfig() {\n        const config = { theta: this.theta };\n        const baseConfig = super.getConfig();\n        Object.assign(config, baseConfig);\n        return config;\n    }\n}\n/** @nocollapse */\nThresholdedReLU.className = 'ThresholdedReLU';\nexport { ThresholdedReLU };\nserialization.registerClass(ThresholdedReLU);\nclass Softmax extends Layer {\n    constructor(args) {\n        super(args == null ? {} : args);\n        this.DEFAULT_AXIS = 1.0;\n        if (args == null) {\n            args = {};\n        }\n        this.softmax = new softmaxActivation().apply;\n        this.axis = args.axis == null ? this.DEFAULT_AXIS : args.axis;\n    }\n    call(inputs, kwargs) {\n        // TODO(pforderique): Add tests for when `this.axis` is a number[].\n        return tidy(() => {\n            let x = getExactlyOneTensor(inputs);\n            const mask = kwargs['mask'];\n            if (mask != null) {\n                // Since mask is 1.0 for positions we want to keep and 0.0 for masked\n                // positions, this operation will create a tensor which is 0.0 for\n                // positions we want to attend and -1e.9 for masked positions.\n                const adder = mul(sub(ones(x.shape), cast(mask, x.dtype)), scalar(-1e9));\n                // Since we are adding it to the raw scores before the softmax, this\n                // is effectively the same as removing these entirely.\n                x = add(x, adder);\n            }\n            if (this.axis instanceof Array) {\n                if (this.axis.length > 1) {\n                    return exp(sub(x, logSumExp(x, this.axis, true)));\n                }\n                else {\n                    return this.softmax(x, this.axis[0]);\n                }\n            }\n            return this.softmax(x, this.axis);\n        });\n    }\n    computeOutputShape(inputShape) {\n        return inputShape;\n    }\n    getConfig() {\n        const config = { axis: this.axis };\n        const baseConfig = super.getConfig();\n        Object.assign(config, baseConfig);\n        return config;\n    }\n}\n/** @nocollapse */\nSoftmax.className = 'Softmax';\nexport { Softmax };\nserialization.registerClass(Softmax);\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced_activations.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/layers/advanced_activations.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Use of this source code is governed by an MIT-style\n * license that can be found in the LICENSE file or at\n * https://opensource.org/licenses/MIT.\n * =============================================================================\n */\n\n/**\n *  Advanced activation layers.\n */\n\nimport {add, cast, clipByValue, elu, exp, greater, leakyRelu, logSumExp, mul, ones, prelu, relu, scalar, serialization, sub, Tensor, tidy} from '@tensorflow/tfjs-core';\n\nimport {Softmax as softmaxActivation} from '../activations';\nimport {Constraint, getConstraint, serializeConstraint} from '../constraints';\nimport {InputSpec, Layer, LayerArgs} from '../engine/topology';\nimport {NotImplementedError, ValueError} from '../errors';\nimport {getInitializer, Initializer, InitializerIdentifier, serializeInitializer} from '../initializers';\nimport {Shape} from '../keras_format/common';\nimport {getRegularizer, Regularizer, serializeRegularizer} from '../regularizers';\nimport {Kwargs} from '../types';\nimport {getExactlyOneShape, getExactlyOneTensor} from '../utils/types_utils';\nimport {LayerVariable} from '../variables';\n\nexport declare interface ReLULayerArgs extends LayerArgs {\n  /**\n   * Float, the maximum output value.\n   */\n  maxValue?: number;\n}\n\nexport class ReLU extends Layer {\n  /** @nocollapse */\n  static className = 'ReLU';\n  maxValue: number;\n\n  constructor(args?: ReLULayerArgs) {\n    super(args == null ? {} : args);\n    this.supportsMasking = true;\n    if (args != null) {\n      this.maxValue = args.maxValue;\n    }\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    inputs = getExactlyOneTensor(inputs);\n    let output = relu(inputs);\n    if (this.maxValue != null) {\n      output = clipByValue(output, 0, this.maxValue);\n    }\n    return output;\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {maxValue: this.maxValue};\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(ReLU);\n\nexport declare interface LeakyReLULayerArgs extends LayerArgs {\n  /**\n   * Float `>= 0`. Negative slope coefficient. Defaults to `0.3`.\n   */\n  alpha?: number;\n}\n\nexport class LeakyReLU extends Layer {\n  /** @nocollapse */\n  static className = 'LeakyReLU';\n  readonly alpha: number;\n\n  readonly DEFAULT_ALPHA = 0.3;\n\n  constructor(args?: LeakyReLULayerArgs) {\n    super(args == null ? {} : args);\n    if (args == null) {\n      args = {};\n    }\n    this.alpha = args.alpha == null ? this.DEFAULT_ALPHA : args.alpha;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    const x = getExactlyOneTensor(inputs);\n    return leakyRelu(x, this.alpha);\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {alpha: this.alpha};\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(LeakyReLU);\n\nexport declare interface PReLULayerArgs extends LayerArgs {\n  /**\n   * Initializer for the learnable alpha.\n   */\n  alphaInitializer?: Initializer|InitializerIdentifier;\n\n  /**\n   * Regularizer for the learnable alpha.\n   */\n  alphaRegularizer?: Regularizer;\n\n  /**\n   * Constraint for the learnable alpha.\n   */\n  alphaConstraint?: Constraint;\n\n  /**\n   * The axes along which to share learnable parameters for the activation\n   * function. For example, if the incoming feature maps are from a 2D\n   * convolution with output shape `[numExamples, height, width, channels]`,\n   * and you wish to share parameters across space (height and width) so that\n   * each filter channels has only one set of parameters, set\n   * `shared_axes: [1, 2]`.\n   */\n  sharedAxes?: number|number[];\n}\n\nexport class PReLU extends Layer {\n  /** @nocollapse */\n  static className = 'PReLU';\n  private readonly alphaInitializer: Initializer;\n  private readonly alphaRegularizer: Regularizer;\n  private readonly alphaConstraint: Constraint;\n  private readonly sharedAxes: number[];\n  private alpha: LayerVariable;\n\n  readonly DEFAULT_ALPHA_INITIALIZER: InitializerIdentifier = 'zeros';\n\n  constructor(args?: PReLULayerArgs) {\n    super(args == null ? {} : args);\n    if (args == null) {\n      args = {};\n    }\n\n    this.supportsMasking = true;\n    this.alphaInitializer =\n        getInitializer(args.alphaInitializer || this.DEFAULT_ALPHA_INITIALIZER);\n    this.alphaRegularizer = getRegularizer(args.alphaRegularizer);\n    this.alphaConstraint = getConstraint(args.alphaConstraint);\n    if (args.sharedAxes == null) {\n      this.sharedAxes = null;\n    } else if (Array.isArray(args.sharedAxes)) {\n      this.sharedAxes = args.sharedAxes;\n    } else if (typeof args.sharedAxes === 'number') {\n      this.sharedAxes = [args.sharedAxes];\n    } else {\n      throw new ValueError(\n          `Expected sharedAxes to be a number or an array of numbers, ` +\n          `but got ${args.sharedAxes}`);\n    }\n  }\n\n  override build(inputShape: Shape|Shape[]) {\n    inputShape = getExactlyOneShape(inputShape);\n    const paramShape: Shape = inputShape.slice(1);\n    if (this.sharedAxes != null) {\n      for (const i of this.sharedAxes) {\n        paramShape[i - 1] = 1;\n      }\n    }\n    this.alpha = this.addWeight(\n        'alpha', paramShape, 'float32', this.alphaInitializer,\n        this.alphaRegularizer, true, this.alphaConstraint);\n    // Set input spec.\n    const axes: {[axis: number]: number} = {};\n    if (this.sharedAxes != null) {\n      for (let i = 1; i < inputShape.length; ++i) {\n        axes[i] = inputShape[i];\n      }\n    }\n    this.inputSpec = [new InputSpec({\n      ndim: inputShape.length,\n      axes,\n    })];\n    this.built = true;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    inputs = getExactlyOneTensor(inputs);\n    return prelu(inputs, this.alpha.read());\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {\n      alphaInitializer: serializeInitializer(this.alphaInitializer),\n      alphaRegularizer: serializeRegularizer(this.alphaRegularizer),\n      alphaConstraint: serializeConstraint(this.alphaConstraint),\n      sharedAxes: this.sharedAxes\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(PReLU);\n\nexport declare interface ELULayerArgs extends LayerArgs {\n  /**\n   * Float `>= 0`. Negative slope coefficient. Defaults to `1.0`.\n   */\n  alpha?: number;\n}\n\nexport class ELU extends Layer {\n  /** @nocollapse */\n  static className = 'ELU';\n  readonly alpha: number;\n\n  readonly DEFAULT_ALPHA = 1.0;\n\n  constructor(args?: ELULayerArgs) {\n    super(args == null ? {} : args);\n    if (args == null) {\n      args = {};\n    }\n\n    if (args.alpha != null && args.alpha !== this.DEFAULT_ALPHA) {\n      throw new NotImplementedError(\n          `Non-default alpha value (${args.alpha}) is not supported by the ` +\n          `ELU layer yet.`);\n    }\n\n    this.alpha = args.alpha == null ? this.DEFAULT_ALPHA : args.alpha;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    const x = getExactlyOneTensor(inputs);\n    return elu(x);\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {alpha: this.alpha};\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(ELU);\n\nexport declare interface ThresholdedReLULayerArgs extends LayerArgs {\n  /**\n   * Float >= 0. Threshold location of activation.\n   */\n  theta?: number;\n}\n\nexport class ThresholdedReLU extends Layer {\n  /** @nocollapse */\n  static className = 'ThresholdedReLU';\n  readonly theta: number;\n\n  readonly DEFAULT_THETA = 1.0;\n\n  constructor(args?: ThresholdedReLULayerArgs) {\n    super(args == null ? {} : args);\n    if (args == null) {\n      args = {};\n    }\n\n    this.theta = args.theta == null ? this.DEFAULT_THETA : args.theta;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    const x = getExactlyOneTensor(inputs);\n    return mul(x, cast(greater(x, this.theta), 'float32'));\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {theta: this.theta};\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(ThresholdedReLU);\n\nexport declare interface SoftmaxLayerArgs extends LayerArgs {\n  /**\n   * Integer, axis along which the softmax normalization is applied.\n   * Defaults to `-1` (i.e., the last axis).\n   */\n  axis?: number|number[];\n}\n\nexport class Softmax extends Layer {\n  /** @nocollapse */\n  static className = 'Softmax';\n  readonly axis: number|number[];\n  readonly softmax: (t: Tensor, a?: number) => Tensor;\n  readonly DEFAULT_AXIS = 1.0;\n\n  constructor(args?: SoftmaxLayerArgs) {\n    super(args == null ? {} : args);\n    if (args == null) {\n      args = {};\n    }\n    this.softmax = new softmaxActivation().apply;\n    this.axis = args.axis == null ? this.DEFAULT_AXIS : args.axis;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    // TODO(pforderique): Add tests for when `this.axis` is a number[].\n    return tidy(() => {\n      let x = getExactlyOneTensor(inputs);\n      const mask = kwargs['mask'] as Tensor;\n      if (mask != null) {\n        // Since mask is 1.0 for positions we want to keep and 0.0 for masked\n        // positions, this operation will create a tensor which is 0.0 for\n        // positions we want to attend and -1e.9 for masked positions.\n        const adder =\n          mul(sub(ones(x.shape), cast(mask, x.dtype)), scalar(-1e9));\n\n        // Since we are adding it to the raw scores before the softmax, this\n        // is effectively the same as removing these entirely.\n        x = add(x, adder);\n      }\n      if (this.axis instanceof Array) {\n        if (this.axis.length > 1) {\n          return exp(sub(x, logSumExp(x, this.axis, true)));\n        } else {\n          return this.softmax(x, this.axis[0]);\n        }\n      }\n      return this.softmax(x, this.axis);\n    });\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {axis: this.axis};\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(Softmax);\n"]}"],"names":["ReLU","Layer","args","inputs","kwargs","getExactlyOneTensor","output","relu","clipByValue","inputShape","config","baseConfig","serialization.registerClass","LeakyReLU","x","leakyRelu","PReLU","getInitializer","getRegularizer","getConstraint","ValueError","getExactlyOneShape","paramShape","i","axes","InputSpec","prelu","serializeInitializer","serializeRegularizer","serializeConstraint","ELU","NotImplementedError","elu","ThresholdedReLU","mul","cast","greater","Softmax","softmaxActivation","tidy","mask","adder","sub","ones","scalar","add","exp","logSumExp"],"mappings":"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","x_google_ignoreList":[0]}