@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer.js

@@ -0,0 +1,106 @@
+import { dispose as o } from "../globals.js";
+import { variableGrads as m } from "../gradients.js";
+import { Serializable as h } from "../serialization.js";
+import { scalar as p } from "../ops/scalar.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class u extends h {
+  /**
+   * Executes `f()` and minimizes the scalar output of `f()` by computing
+   * gradients of y with respect to the list of trainable variables provided by
+   * `varList`. If no list is provided, it defaults to all trainable variables.
+   *
+   * @param f The function to execute and whose output to minimize.
+   * @param returnCost Whether to return the scalar cost value produced by
+   * executing `f()`.
+   * @param varList An optional list of variables to update. If specified, only
+   * the trainable variables in varList will be updated by minimize. Defaults to
+   * all trainable variables.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers'}
+   */
+  minimize(t, i = !1, s) {
+    const { value: n, grads: r } = this.computeGradients(t, s);
+    if (s != null) {
+      const l = s.map((a) => ({ name: a.name, tensor: r[a.name] }));
+      this.applyGradients(l);
+    } else
+      this.applyGradients(r);
+    return o(r), i ? n : (n.dispose(), null);
+  }
+  /**
+   * The number of iterations that this optimizer instance has been invoked for.
+   */
+  get iterations() {
+    return this.iterations_ == null && (this.iterations_ = 0), this.iterations_;
+  }
+  incrementIterations() {
+    this.iterations_ = this.iterations + 1;
+  }
+  /**
+   * Executes f() and computes the gradient of the scalar output of f() with
+   * respect to the list of trainable variables provided by `varList`. If no
+   * list is provided, it defaults to all trainable variables.
+   *
+   * @param f The function to execute and whose output to use for computing
+   * gradients with respect to variables.
+   * @param varList An optional list of variables to compute gradients with
+   * respect to. If specified, only the trainable variables in varList will have
+   * gradients computed with respect to. Defaults to all trainable variables.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers'}
+   */
+  computeGradients(t, i) {
+    return m(t, i);
+  }
+  /**
+   * Dispose the variables (if any) owned by this optimizer instance.
+   */
+  dispose() {
+    this.iterations_ != null && o(this.iterations_);
+  }
+  async saveIterations() {
+    return this.iterations_ == null && (this.iterations_ = 0), {
+      name: "iter",
+      // TODO(cais): Use 'int64' type when available.
+      tensor: p(this.iterations_, "int32")
+    };
+  }
+  async getWeights() {
+    throw new Error("getWeights() is not implemented for this optimizer yet.");
+  }
+  async setWeights(t) {
+    throw new Error(`setWeights() is not implemented for this optimizer class ${this.getClassName()}`);
+  }
+  /**
+   * Extract the first element of the weight values and set it
+   * as the iterations counter variable of this instance of optimizer.
+   *
+   * @param weightValues
+   * @returns Weight values with the first element consumed and excluded.
+   */
+  async extractIterations(t) {
+    return this.iterations_ = (await t[0].tensor.data())[0], t.slice(1);
+  }
+}
+Object.defineProperty(u, Symbol.hasInstance, {
+  value: (e) => e.minimize != null && e.computeGradients != null && e.applyGradients != null
+});
+export {
+  u as Optimizer
+};
+//# sourceMappingURL=optimizer.js.map

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer.js"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { dispose } from '../globals';\nimport { variableGrads } from '../gradients';\nimport { scalar } from '../ops/ops';\nimport { Serializable } from '../serialization';\n/** @doc {heading: 'Training', subheading: 'Classes', namespace: 'train'} */\nexport class Optimizer extends Serializable {\n    /**\n     * Executes `f()` and minimizes the scalar output of `f()` by computing\n     * gradients of y with respect to the list of trainable variables provided by\n     * `varList`. If no list is provided, it defaults to all trainable variables.\n     *\n     * @param f The function to execute and whose output to minimize.\n     * @param returnCost Whether to return the scalar cost value produced by\n     * executing `f()`.\n     * @param varList An optional list of variables to update. If specified, only\n     * the trainable variables in varList will be updated by minimize. Defaults to\n     * all trainable variables.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers'}\n     */\n    minimize(f, returnCost = false, varList) {\n        const { value, grads } = this.computeGradients(f, varList);\n        if (varList != null) {\n            const gradArray = varList.map(v => ({ name: v.name, tensor: grads[v.name] }));\n            this.applyGradients(gradArray);\n        }\n        else {\n            this.applyGradients(grads);\n        }\n        // Dispose gradients.\n        dispose(grads);\n        if (returnCost) {\n            return value;\n        }\n        else {\n            value.dispose();\n            return null;\n        }\n    }\n    /**\n     * The number of iterations that this optimizer instance has been invoked for.\n     */\n    get iterations() {\n        if (this.iterations_ == null) {\n            this.iterations_ = 0;\n        }\n        return this.iterations_;\n    }\n    incrementIterations() {\n        this.iterations_ = this.iterations + 1;\n    }\n    /**\n     * Executes f() and computes the gradient of the scalar output of f() with\n     * respect to the list of trainable variables provided by `varList`. If no\n     * list is provided, it defaults to all trainable variables.\n     *\n     * @param f The function to execute and whose output to use for computing\n     * gradients with respect to variables.\n     * @param varList An optional list of variables to compute gradients with\n     * respect to. If specified, only the trainable variables in varList will have\n     * gradients computed with respect to. Defaults to all trainable variables.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers'}\n     */\n    computeGradients(f, varList) {\n        return variableGrads(f, varList);\n    }\n    /**\n     * Dispose the variables (if any) owned by this optimizer instance.\n     */\n    dispose() {\n        if (this.iterations_ != null) {\n            dispose(this.iterations_);\n        }\n    }\n    async saveIterations() {\n        if (this.iterations_ == null) {\n            this.iterations_ = 0;\n        }\n        return {\n            name: 'iter',\n            // TODO(cais): Use 'int64' type when available.\n            tensor: scalar(this.iterations_, 'int32')\n        };\n    }\n    async getWeights() {\n        throw new Error('getWeights() is not implemented for this optimizer yet.');\n    }\n    async setWeights(weightValues) {\n        throw new Error(`setWeights() is not implemented for this optimizer class ` +\n            `${this.getClassName()}`);\n    }\n    /**\n     * Extract the first element of the weight values and set it\n     * as the iterations counter variable of this instance of optimizer.\n     *\n     * @param weightValues\n     * @returns Weight values with the first element consumed and excluded.\n     */\n    async extractIterations(weightValues) {\n        this.iterations_ = (await weightValues[0].tensor.data())[0];\n        return weightValues.slice(1);\n    }\n}\nObject.defineProperty(Optimizer, Symbol.hasInstance, {\n    value: (instance) => {\n        return instance.minimize != null && instance.computeGradients != null &&\n            instance.applyGradients != null;\n    }\n});\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"optimizer.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/optimizers/optimizer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {dispose} from '../globals';\nimport {variableGrads} from '../gradients';\nimport {scalar} from '../ops/ops';\nimport {Serializable} from '../serialization';\nimport {Scalar, Variable} from '../tensor';\nimport {NamedTensor, NamedTensorMap} from '../tensor_types';\n\n/**\n * A variable that belongs to an optimizer.\n *\n * The `originalName` field is required for keeping track of the canonical\n * name of the variable, which is usually the name of the model weight that\n * the variable is related to plus a suffix, e.g., 'dense1/kernel/momentum'.\n * The name of the `Variable` object itself cannot be used directly due to\n * possible deduplication: Every `Variable` must have a unique name but more\n * than one optimizer objects of the same type may be created for the same model\n * or the same `Variable`.\n */\nexport interface OptimizerVariable {\n  originalName: string;\n  variable: Variable;\n}\n\n/** @doc {heading: 'Training', subheading: 'Classes', namespace: 'train'} */\nexport abstract class Optimizer extends Serializable {\n  protected iterations_: number;\n\n  /**\n   * Executes `f()` and minimizes the scalar output of `f()` by computing\n   * gradients of y with respect to the list of trainable variables provided by\n   * `varList`. If no list is provided, it defaults to all trainable variables.\n   *\n   * @param f The function to execute and whose output to minimize.\n   * @param returnCost Whether to return the scalar cost value produced by\n   * executing `f()`.\n   * @param varList An optional list of variables to update. If specified, only\n   * the trainable variables in varList will be updated by minimize. Defaults to\n   * all trainable variables.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers'}\n   */\n  minimize(f: () => Scalar, returnCost = false, varList?: Variable[]): Scalar\n      |null {\n    const {value, grads} = this.computeGradients(f, varList);\n\n    if (varList != null) {\n      const gradArray: NamedTensor[] =\n          varList.map(v => ({name: v.name, tensor: grads[v.name]}));\n      this.applyGradients(gradArray);\n    } else {\n      this.applyGradients(grads);\n    }\n\n    // Dispose gradients.\n    dispose(grads);\n\n    if (returnCost) {\n      return value;\n    } else {\n      value.dispose();\n      return null;\n    }\n  }\n\n  /**\n   * The number of iterations that this optimizer instance has been invoked for.\n   */\n  get iterations(): number {\n    if (this.iterations_ == null) {\n      this.iterations_ = 0;\n    }\n    return this.iterations_;\n  }\n\n  protected incrementIterations() {\n    this.iterations_ = this.iterations + 1;\n  }\n\n  /**\n   * Executes f() and computes the gradient of the scalar output of f() with\n   * respect to the list of trainable variables provided by `varList`. If no\n   * list is provided, it defaults to all trainable variables.\n   *\n   * @param f The function to execute and whose output to use for computing\n   * gradients with respect to variables.\n   * @param varList An optional list of variables to compute gradients with\n   * respect to. If specified, only the trainable variables in varList will have\n   * gradients computed with respect to. Defaults to all trainable variables.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers'}\n   */\n  computeGradients(f: () => Scalar, varList?: Variable[]):\n      {value: Scalar, grads: NamedTensorMap} {\n    return variableGrads(f, varList);\n  }\n\n  /**\n   * Updates variables by using the computed gradients.\n   *\n   * @param variableGradients A mapping of variable name to its gradient value.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers'}\n   */\n  abstract applyGradients(variableGradients: NamedTensorMap|\n                          NamedTensor[]): void;\n\n  /**\n   * Dispose the variables (if any) owned by this optimizer instance.\n   */\n  dispose(): void {\n    if (this.iterations_ != null) {\n      dispose(this.iterations_);\n    }\n  }\n\n  async saveIterations(): Promise<NamedTensor> {\n    if (this.iterations_ == null) {\n      this.iterations_ = 0;\n    }\n    return {\n      name: 'iter',  // Named for Python compatibility.\n      // TODO(cais): Use 'int64' type when available.\n      tensor: scalar(this.iterations_, 'int32')\n    };\n  }\n\n  async getWeights(): Promise<NamedTensor[]> {\n    throw new Error('getWeights() is not implemented for this optimizer yet.');\n  }\n\n  async setWeights(weightValues: NamedTensor[]): Promise<void> {\n    throw new Error(\n        `setWeights() is not implemented for this optimizer class ` +\n        `${this.getClassName()}`);\n  }\n\n  /**\n   * Extract the first element of the weight values and set it\n   * as the iterations counter variable of this instance of optimizer.\n   *\n   * @param weightValues\n   * @returns Weight values with the first element consumed and excluded.\n   */\n  protected async extractIterations(weightValues: NamedTensor[]):\n      Promise<NamedTensor[]> {\n    this.iterations_ = (await weightValues[0].tensor.data())[0];\n    return weightValues.slice(1);\n  }\n}\n\nObject.defineProperty(Optimizer, Symbol.hasInstance, {\n  value: (instance: Optimizer) => {\n    return instance.minimize != null && instance.computeGradients != null &&\n        instance.applyGradients != null;\n  }\n});\n"]}"],"names":["Optimizer","Serializable","f","returnCost","varList","value","grads","gradArray","v","dispose","variableGrads","scalar","weightValues","instance"],"mappings":";;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,MAAMA,UAAkBC,EAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAexC,SAASC,GAAGC,IAAa,IAAOC,GAAS;AACrC,UAAM,EAAE,OAAAC,GAAO,OAAAC,EAAO,IAAG,KAAK,iBAAiBJ,GAAGE,CAAO;AACzD,QAAIA,KAAW,MAAM;AACjB,YAAMG,IAAYH,EAAQ,IAAI,CAAAI,OAAM,EAAE,MAAMA,EAAE,MAAM,QAAQF,EAAME,EAAE,IAAI,EAAC,EAAG;AAC5E,WAAK,eAAeD,CAAS;AAAA,IAChC;AAEG,WAAK,eAAeD,CAAK;AAI7B,WADAG,EAAQH,CAAK,GACTH,IACOE,KAGPA,EAAM,QAAO,GACN;AAAA,EAEd;AAAA;AAAA;AAAA;AAAA,EAID,IAAI,aAAa;AACb,WAAI,KAAK,eAAe,SACpB,KAAK,cAAc,IAEhB,KAAK;AAAA,EACf;AAAA,EACD,sBAAsB;AAClB,SAAK,cAAc,KAAK,aAAa;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcD,iBAAiBH,GAAGE,GAAS;AACzB,WAAOM,EAAcR,GAAGE,CAAO;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA,EAID,UAAU;AACN,IAAI,KAAK,eAAe,QACpBK,EAAQ,KAAK,WAAW;AAAA,EAE/B;AAAA,EACD,MAAM,iBAAiB;AACnB,WAAI,KAAK,eAAe,SACpB,KAAK,cAAc,IAEhB;AAAA,MACH,MAAM;AAAA;AAAA,MAEN,QAAQE,EAAO,KAAK,aAAa,OAAO;AAAA,IACpD;AAAA,EACK;AAAA,EACD,MAAM,aAAa;AACf,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC5E;AAAA,EACD,MAAM,WAAWC,GAAc;AAC3B,UAAM,IAAI,MAAM,4DACT,KAAK,aAAc,CAAA,EAAE;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQD,MAAM,kBAAkBA,GAAc;AAClC,gBAAK,eAAe,MAAMA,EAAa,CAAC,EAAE,OAAO,QAAQ,CAAC,GACnDA,EAAa,MAAM,CAAC;AAAA,EAC9B;AACL;AACA,OAAO,eAAeZ,GAAW,OAAO,aAAa;AAAA,EACjD,OAAO,CAACa,MACGA,EAAS,YAAY,QAAQA,EAAS,oBAAoB,QAC7DA,EAAS,kBAAkB;AAEvC,CAAC;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer_constructors.js

@@ -0,0 +1,175 @@
+import { AdadeltaOptimizer as a } from "./adadelta_optimizer.js";
+import { AdagradOptimizer as n } from "./adagrad_optimizer.js";
+import { AdamOptimizer as o } from "./adam_optimizer.js";
+import { AdamaxOptimizer as p } from "./adamax_optimizer.js";
+import { MomentumOptimizer as s } from "./momentum_optimizer.js";
+import { RMSPropOptimizer as u } from "./rmsprop_optimizer.js";
+import { SGDOptimizer as d } from "./sgd_optimizer.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class x {
+  /**
+   * Constructs a `tf.SGDOptimizer` that uses stochastic gradient descent.
+   *
+   * ```js
+   * // Fit a quadratic function by learning the coefficients a, b, c.
+   * const xs = tf.tensor1d([0, 1, 2, 3]);
+   * const ys = tf.tensor1d([1.1, 5.9, 16.8, 33.9]);
+   *
+   * const a = tf.scalar(Math.random()).variable();
+   * const b = tf.scalar(Math.random()).variable();
+   * const c = tf.scalar(Math.random()).variable();
+   *
+   * // y = a * x^2 + b * x + c.
+   * const f = x => a.mul(x.square()).add(b.mul(x)).add(c);
+   * const loss = (pred, label) => pred.sub(label).square().mean();
+   *
+   * const learningRate = 0.01;
+   * const optimizer = tf.train.sgd(learningRate);
+   *
+   * // Train the model.
+   * for (let i = 0; i < 10; i++) {
+   *   optimizer.minimize(() => loss(f(xs), ys));
+   * }
+   *
+   * // Make predictions.
+   * console.log(
+   *     `a: ${a.dataSync()}, b: ${b.dataSync()}, c: ${c.dataSync()}`);
+   * const preds = f(xs).dataSync();
+   * preds.forEach((pred, i) => {
+   *   console.log(`x: ${i}, pred: ${pred}`);
+   * });
+   * ```
+   *
+   * @param learningRate The learning rate to use for the SGD algorithm.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static sgd(r) {
+    return new d(r);
+  }
+  /**
+   * Constructs a `tf.MomentumOptimizer` that uses momentum gradient
+   * descent.
+   *
+   * See
+   * [http://proceedings.mlr.press/v28/sutskever13.pdf](
+   * http://proceedings.mlr.press/v28/sutskever13.pdf)
+   *
+   * @param learningRate The learning rate to use for the Momentum gradient
+   * descent algorithm.
+   * @param momentum The momentum to use for the momentum gradient descent
+   * algorithm.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static momentum(r, t, m = !1) {
+    return new s(r, t, m);
+  }
+  /**
+   * Constructs a `tf.RMSPropOptimizer` that uses RMSProp gradient
+   * descent. This implementation uses plain momentum and is not centered
+   * version of RMSProp.
+   *
+   * See
+   * [http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf](
+   * http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf)
+   *
+   * @param learningRate The learning rate to use for the RMSProp gradient
+   * descent algorithm.
+   * @param decay The discounting factor for the history/coming gradient.
+   * @param momentum The momentum to use for the RMSProp gradient descent
+   * algorithm.
+   * @param epsilon Small value to avoid zero denominator.
+   * @param centered If true, gradients are normalized by the estimated
+   * variance of the gradient.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static rmsprop(r, t = 0.9, m = 0, i = null, e = !1) {
+    return new u(r, t, m, i, e);
+  }
+  /**
+   * Constructs a `tf.AdamOptimizer` that uses the Adam algorithm.
+   * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)
+   *
+   * @param learningRate The learning rate to use for the Adam gradient
+   * descent algorithm.
+   * @param beta1 The exponential decay rate for the 1st moment estimates.
+   * @param beta2 The exponential decay rate for the 2nd moment estimates.
+   * @param epsilon A small constant for numerical stability.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static adam(r = 1e-3, t = 0.9, m = 0.999, i = null) {
+    return new o(r, t, m, i);
+  }
+  /**
+   * Constructs a `tf.AdadeltaOptimizer` that uses the Adadelta algorithm.
+   * See [https://arxiv.org/abs/1212.5701](https://arxiv.org/abs/1212.5701)
+   *
+   * @param learningRate The learning rate to use for the Adadelta gradient
+   * descent algorithm.
+   * @param rho The learning rate decay over each update.
+   * @param epsilon A constant epsilon used to better condition the grad
+   * update.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static adadelta(r = 1e-3, t = 0.95, m = null) {
+    return new a(r, t, m);
+  }
+  /**
+   * Constructs a `tf.AdamaxOptimizer` that uses the Adamax algorithm.
+   * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)
+   *
+   * @param learningRate The learning rate to use for the Adamax gradient
+   * descent algorithm.
+   * @param beta1 The exponential decay rate for the 1st moment estimates.
+   * @param beta2 The exponential decay rate for the 2nd moment estimates.
+   * @param epsilon A small constant for numerical stability.
+   * @param decay The learning rate decay over each update.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static adamax(r = 2e-3, t = 0.9, m = 0.999, i = null, e = 0) {
+    return new p(r, t, m, i, e);
+  }
+  /**
+   * Constructs a `tf.AdagradOptimizer` that uses the Adagrad algorithm.
+   * See
+   * [http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf](
+   * http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)
+   * or
+   * [http://ruder.io/optimizing-gradient-descent/index.html#adagrad](
+   * http://ruder.io/optimizing-gradient-descent/index.html#adagrad)
+   *
+   * @param learningRate The learning rate to use for the Adagrad gradient
+   * descent algorithm.
+   * @param initialAccumulatorValue Starting value for the accumulators, must be
+   * positive.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+   */
+  static adagrad(r, t = 0.1) {
+    return new n(r, t);
+  }
+}
+export {
+  x as OptimizerConstructors
+};
+//# sourceMappingURL=optimizer_constructors.js.map

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer_constructors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer_constructors.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer_constructors.js"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { AdadeltaOptimizer } from './adadelta_optimizer';\nimport { AdagradOptimizer } from './adagrad_optimizer';\nimport { AdamOptimizer } from './adam_optimizer';\nimport { AdamaxOptimizer } from './adamax_optimizer';\nimport { MomentumOptimizer } from './momentum_optimizer';\nimport { RMSPropOptimizer } from './rmsprop_optimizer';\nimport { SGDOptimizer } from './sgd_optimizer';\nexport class OptimizerConstructors {\n    /**\n     * Constructs a `tf.SGDOptimizer` that uses stochastic gradient descent.\n     *\n     * ```js\n     * // Fit a quadratic function by learning the coefficients a, b, c.\n     * const xs = tf.tensor1d([0, 1, 2, 3]);\n     * const ys = tf.tensor1d([1.1, 5.9, 16.8, 33.9]);\n     *\n     * const a = tf.scalar(Math.random()).variable();\n     * const b = tf.scalar(Math.random()).variable();\n     * const c = tf.scalar(Math.random()).variable();\n     *\n     * // y = a * x^2 + b * x + c.\n     * const f = x => a.mul(x.square()).add(b.mul(x)).add(c);\n     * const loss = (pred, label) => pred.sub(label).square().mean();\n     *\n     * const learningRate = 0.01;\n     * const optimizer = tf.train.sgd(learningRate);\n     *\n     * // Train the model.\n     * for (let i = 0; i < 10; i++) {\n     *   optimizer.minimize(() => loss(f(xs), ys));\n     * }\n     *\n     * // Make predictions.\n     * console.log(\n     *     `a: ${a.dataSync()}, b: ${b.dataSync()}, c: ${c.dataSync()}`);\n     * const preds = f(xs).dataSync();\n     * preds.forEach((pred, i) => {\n     *   console.log(`x: ${i}, pred: ${pred}`);\n     * });\n     * ```\n     *\n     * @param learningRate The learning rate to use for the SGD algorithm.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static sgd(learningRate) {\n        return new SGDOptimizer(learningRate);\n    }\n    /**\n     * Constructs a `tf.MomentumOptimizer` that uses momentum gradient\n     * descent.\n     *\n     * See\n     * [http://proceedings.mlr.press/v28/sutskever13.pdf](\n     * http://proceedings.mlr.press/v28/sutskever13.pdf)\n     *\n     * @param learningRate The learning rate to use for the Momentum gradient\n     * descent algorithm.\n     * @param momentum The momentum to use for the momentum gradient descent\n     * algorithm.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static momentum(learningRate, momentum, useNesterov = false) {\n        return new MomentumOptimizer(learningRate, momentum, useNesterov);\n    }\n    /**\n     * Constructs a `tf.RMSPropOptimizer` that uses RMSProp gradient\n     * descent. This implementation uses plain momentum and is not centered\n     * version of RMSProp.\n     *\n     * See\n     * [http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf](\n     * http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf)\n     *\n     * @param learningRate The learning rate to use for the RMSProp gradient\n     * descent algorithm.\n     * @param decay The discounting factor for the history/coming gradient.\n     * @param momentum The momentum to use for the RMSProp gradient descent\n     * algorithm.\n     * @param epsilon Small value to avoid zero denominator.\n     * @param centered If true, gradients are normalized by the estimated\n     * variance of the gradient.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static rmsprop(learningRate, decay = .9, momentum = 0.0, epsilon = null, centered = false) {\n        return new RMSPropOptimizer(learningRate, decay, momentum, epsilon, centered);\n    }\n    /**\n     * Constructs a `tf.AdamOptimizer` that uses the Adam algorithm.\n     * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)\n     *\n     * @param learningRate The learning rate to use for the Adam gradient\n     * descent algorithm.\n     * @param beta1 The exponential decay rate for the 1st moment estimates.\n     * @param beta2 The exponential decay rate for the 2nd moment estimates.\n     * @param epsilon A small constant for numerical stability.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static adam(learningRate = 0.001, beta1 = 0.9, beta2 = 0.999, epsilon = null) {\n        return new AdamOptimizer(learningRate, beta1, beta2, epsilon);\n    }\n    /**\n     * Constructs a `tf.AdadeltaOptimizer` that uses the Adadelta algorithm.\n     * See [https://arxiv.org/abs/1212.5701](https://arxiv.org/abs/1212.5701)\n     *\n     * @param learningRate The learning rate to use for the Adadelta gradient\n     * descent algorithm.\n     * @param rho The learning rate decay over each update.\n     * @param epsilon A constant epsilon used to better condition the grad\n     * update.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static adadelta(learningRate = .001, rho = .95, epsilon = null) {\n        return new AdadeltaOptimizer(learningRate, rho, epsilon);\n    }\n    /**\n     * Constructs a `tf.AdamaxOptimizer` that uses the Adamax algorithm.\n     * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)\n     *\n     * @param learningRate The learning rate to use for the Adamax gradient\n     * descent algorithm.\n     * @param beta1 The exponential decay rate for the 1st moment estimates.\n     * @param beta2 The exponential decay rate for the 2nd moment estimates.\n     * @param epsilon A small constant for numerical stability.\n     * @param decay The learning rate decay over each update.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static adamax(learningRate = 0.002, beta1 = 0.9, beta2 = 0.999, epsilon = null, decay = 0.0) {\n        return new AdamaxOptimizer(learningRate, beta1, beta2, epsilon, decay);\n    }\n    /**\n     * Constructs a `tf.AdagradOptimizer` that uses the Adagrad algorithm.\n     * See\n     * [http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf](\n     * http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)\n     * or\n     * [http://ruder.io/optimizing-gradient-descent/index.html#adagrad](\n     * http://ruder.io/optimizing-gradient-descent/index.html#adagrad)\n     *\n     * @param learningRate The learning rate to use for the Adagrad gradient\n     * descent algorithm.\n     * @param initialAccumulatorValue Starting value for the accumulators, must be\n     * positive.\n     *\n     * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n     */\n    static adagrad(learningRate, initialAccumulatorValue = 0.1) {\n        return new AdagradOptimizer(learningRate, initialAccumulatorValue);\n    }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"optimizer_constructors.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/optimizers/optimizer_constructors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAE7C,MAAM,OAAO,qBAAqB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,MAAM,CAAC,GAAG,CAAC,YAAoB;QAC7B,OAAO,IAAI,YAAY,CAAC,YAAY,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,QAAQ,CAAC,YAAoB,EAAE,QAAgB,EAAE,WAAW,GAAG,KAAK;QAEzE,OAAO,IAAI,iBAAiB,CAAC,YAAY,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,OAAO,CACV,YAAoB,EAAE,KAAK,GAAG,EAAE,EAAE,QAAQ,GAAG,GAAG,EAAE,UAAkB,IAAI,EACxE,QAAQ,GAAG,KAAK;QAClB,OAAO,IAAI,gBAAgB,CACvB,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,IAAI,CACP,YAAY,GAAG,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,GAAG,KAAK,EAChD,UAAkB,IAAI;QACxB,OAAO,IAAI,aAAa,CAAC,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,UAAkB,IAAI;QAEpE,OAAO,IAAI,iBAAiB,CAAC,YAAY,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,MAAM,CACT,YAAY,GAAG,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,GAAG,KAAK,EAAE,UAAkB,IAAI,EACxE,KAAK,GAAG,GAAG;QACb,OAAO,IAAI,eAAe,CAAC,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,CAAC,YAAoB,EAAE,uBAAuB,GAAG,GAAG;QAEhE,OAAO,IAAI,gBAAgB,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC;IACrE,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {AdadeltaOptimizer} from './adadelta_optimizer';\nimport {AdagradOptimizer} from './adagrad_optimizer';\nimport {AdamOptimizer} from './adam_optimizer';\nimport {AdamaxOptimizer} from './adamax_optimizer';\nimport {MomentumOptimizer} from './momentum_optimizer';\nimport {RMSPropOptimizer} from './rmsprop_optimizer';\nimport {SGDOptimizer} from './sgd_optimizer';\n\nexport class OptimizerConstructors {\n  /**\n   * Constructs a `tf.SGDOptimizer` that uses stochastic gradient descent.\n   *\n   * ```js\n   * // Fit a quadratic function by learning the coefficients a, b, c.\n   * const xs = tf.tensor1d([0, 1, 2, 3]);\n   * const ys = tf.tensor1d([1.1, 5.9, 16.8, 33.9]);\n   *\n   * const a = tf.scalar(Math.random()).variable();\n   * const b = tf.scalar(Math.random()).variable();\n   * const c = tf.scalar(Math.random()).variable();\n   *\n   * // y = a * x^2 + b * x + c.\n   * const f = x => a.mul(x.square()).add(b.mul(x)).add(c);\n   * const loss = (pred, label) => pred.sub(label).square().mean();\n   *\n   * const learningRate = 0.01;\n   * const optimizer = tf.train.sgd(learningRate);\n   *\n   * // Train the model.\n   * for (let i = 0; i < 10; i++) {\n   *   optimizer.minimize(() => loss(f(xs), ys));\n   * }\n   *\n   * // Make predictions.\n   * console.log(\n   *     `a: ${a.dataSync()}, b: ${b.dataSync()}, c: ${c.dataSync()}`);\n   * const preds = f(xs).dataSync();\n   * preds.forEach((pred, i) => {\n   *   console.log(`x: ${i}, pred: ${pred}`);\n   * });\n   * ```\n   *\n   * @param learningRate The learning rate to use for the SGD algorithm.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static sgd(learningRate: number): SGDOptimizer {\n    return new SGDOptimizer(learningRate);\n  }\n\n  /**\n   * Constructs a `tf.MomentumOptimizer` that uses momentum gradient\n   * descent.\n   *\n   * See\n   * [http://proceedings.mlr.press/v28/sutskever13.pdf](\n   * http://proceedings.mlr.press/v28/sutskever13.pdf)\n   *\n   * @param learningRate The learning rate to use for the Momentum gradient\n   * descent algorithm.\n   * @param momentum The momentum to use for the momentum gradient descent\n   * algorithm.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static momentum(learningRate: number, momentum: number, useNesterov = false):\n      MomentumOptimizer {\n    return new MomentumOptimizer(learningRate, momentum, useNesterov);\n  }\n\n  /**\n   * Constructs a `tf.RMSPropOptimizer` that uses RMSProp gradient\n   * descent. This implementation uses plain momentum and is not centered\n   * version of RMSProp.\n   *\n   * See\n   * [http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf](\n   * http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf)\n   *\n   * @param learningRate The learning rate to use for the RMSProp gradient\n   * descent algorithm.\n   * @param decay The discounting factor for the history/coming gradient.\n   * @param momentum The momentum to use for the RMSProp gradient descent\n   * algorithm.\n   * @param epsilon Small value to avoid zero denominator.\n   * @param centered If true, gradients are normalized by the estimated\n   * variance of the gradient.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static rmsprop(\n      learningRate: number, decay = .9, momentum = 0.0, epsilon: number = null,\n      centered = false): RMSPropOptimizer {\n    return new RMSPropOptimizer(\n        learningRate, decay, momentum, epsilon, centered);\n  }\n\n  /**\n   * Constructs a `tf.AdamOptimizer` that uses the Adam algorithm.\n   * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)\n   *\n   * @param learningRate The learning rate to use for the Adam gradient\n   * descent algorithm.\n   * @param beta1 The exponential decay rate for the 1st moment estimates.\n   * @param beta2 The exponential decay rate for the 2nd moment estimates.\n   * @param epsilon A small constant for numerical stability.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static adam(\n      learningRate = 0.001, beta1 = 0.9, beta2 = 0.999,\n      epsilon: number = null): AdamOptimizer {\n    return new AdamOptimizer(learningRate, beta1, beta2, epsilon);\n  }\n\n  /**\n   * Constructs a `tf.AdadeltaOptimizer` that uses the Adadelta algorithm.\n   * See [https://arxiv.org/abs/1212.5701](https://arxiv.org/abs/1212.5701)\n   *\n   * @param learningRate The learning rate to use for the Adadelta gradient\n   * descent algorithm.\n   * @param rho The learning rate decay over each update.\n   * @param epsilon A constant epsilon used to better condition the grad\n   * update.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static adadelta(learningRate = .001, rho = .95, epsilon: number = null):\n      AdadeltaOptimizer {\n    return new AdadeltaOptimizer(learningRate, rho, epsilon);\n  }\n\n  /**\n   * Constructs a `tf.AdamaxOptimizer` that uses the Adamax algorithm.\n   * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)\n   *\n   * @param learningRate The learning rate to use for the Adamax gradient\n   * descent algorithm.\n   * @param beta1 The exponential decay rate for the 1st moment estimates.\n   * @param beta2 The exponential decay rate for the 2nd moment estimates.\n   * @param epsilon A small constant for numerical stability.\n   * @param decay The learning rate decay over each update.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static adamax(\n      learningRate = 0.002, beta1 = 0.9, beta2 = 0.999, epsilon: number = null,\n      decay = 0.0): AdamaxOptimizer {\n    return new AdamaxOptimizer(learningRate, beta1, beta2, epsilon, decay);\n  }\n\n  /**\n   * Constructs a `tf.AdagradOptimizer` that uses the Adagrad algorithm.\n   * See\n   * [http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf](\n   * http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)\n   * or\n   * [http://ruder.io/optimizing-gradient-descent/index.html#adagrad](\n   * http://ruder.io/optimizing-gradient-descent/index.html#adagrad)\n   *\n   * @param learningRate The learning rate to use for the Adagrad gradient\n   * descent algorithm.\n   * @param initialAccumulatorValue Starting value for the accumulators, must be\n   * positive.\n   *\n   * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}\n   */\n  static adagrad(learningRate: number, initialAccumulatorValue = 0.1):\n      AdagradOptimizer {\n    return new AdagradOptimizer(learningRate, initialAccumulatorValue);\n  }\n}\n"]}"],"names":["OptimizerConstructors","learningRate","SGDOptimizer","momentum","useNesterov","MomentumOptimizer","decay","epsilon","centered","RMSPropOptimizer","beta1","beta2","AdamOptimizer","rho","AdadeltaOptimizer","AdamaxOptimizer","initialAccumulatorValue","AdagradOptimizer"],"mappings":";;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBO,MAAMA,EAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsC/B,OAAO,IAAIC,GAAc;AACrB,WAAO,IAAIC,EAAaD,CAAY;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBD,OAAO,SAASA,GAAcE,GAAUC,IAAc,IAAO;AACzD,WAAO,IAAIC,EAAkBJ,GAAcE,GAAUC,CAAW;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqBD,OAAO,QAAQH,GAAcK,IAAQ,KAAIH,IAAW,GAAKI,IAAU,MAAMC,IAAW,IAAO;AACvF,WAAO,IAAIC,EAAiBR,GAAcK,GAAOH,GAAUI,GAASC,CAAQ;AAAA,EAC/E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaD,OAAO,KAAKP,IAAe,MAAOS,IAAQ,KAAKC,IAAQ,OAAOJ,IAAU,MAAM;AAC1E,WAAO,IAAIK,EAAcX,GAAcS,GAAOC,GAAOJ,CAAO;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaD,OAAO,SAASN,IAAe,MAAMY,IAAM,MAAKN,IAAU,MAAM;AAC5D,WAAO,IAAIO,EAAkBb,GAAcY,GAAKN,CAAO;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcD,OAAO,OAAON,IAAe,MAAOS,IAAQ,KAAKC,IAAQ,OAAOJ,IAAU,MAAMD,IAAQ,GAAK;AACzF,WAAO,IAAIS,EAAgBd,GAAcS,GAAOC,GAAOJ,GAASD,CAAK;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBD,OAAO,QAAQL,GAAce,IAA0B,KAAK;AACxD,WAAO,IAAIC,EAAiBhB,GAAce,CAAuB;AAAA,EACpE;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/register_optimizers.js

@@ -0,0 +1,41 @@
+import { AdadeltaOptimizer as i } from "./adadelta_optimizer.js";
+import { AdagradOptimizer as m } from "./adagrad_optimizer.js";
+import { AdamOptimizer as o } from "./adam_optimizer.js";
+import { AdamaxOptimizer as t } from "./adamax_optimizer.js";
+import { MomentumOptimizer as p } from "./momentum_optimizer.js";
+import { RMSPropOptimizer as e } from "./rmsprop_optimizer.js";
+import { SGDOptimizer as f } from "./sgd_optimizer.js";
+import { registerClass as z } from "../serialization.js";
+/**
+ * @license
+ * Copyright 2022 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const O = [
+  i,
+  m,
+  o,
+  t,
+  p,
+  e,
+  f
+];
+function S() {
+  for (const r of O)
+    z(r);
+}
+export {
+  S as registerOptimizers
+};
+//# sourceMappingURL=register_optimizers.js.map

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/register_optimizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register_optimizers.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-core/dist/optimizers/register_optimizers.js"],"sourcesContent":["/**\n * @license\n * Copyright 2022 Google LLC.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { AdadeltaOptimizer } from './adadelta_optimizer';\nimport { AdagradOptimizer } from './adagrad_optimizer';\nimport { AdamOptimizer } from './adam_optimizer';\nimport { AdamaxOptimizer } from './adamax_optimizer';\nimport { MomentumOptimizer } from './momentum_optimizer';\nimport { RMSPropOptimizer } from './rmsprop_optimizer';\nimport { SGDOptimizer } from './sgd_optimizer';\nimport { registerClass } from '../serialization';\nconst OPTIMIZERS = [\n    AdadeltaOptimizer,\n    AdagradOptimizer,\n    AdamOptimizer,\n    AdamaxOptimizer,\n    MomentumOptimizer,\n    RMSPropOptimizer,\n    SGDOptimizer,\n];\nexport function registerOptimizers() {\n    for (const optimizer of OPTIMIZERS) {\n        registerClass(optimizer);\n    }\n}\n//# sourceMappingURL=data:application/json;base64,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"],"names":["OPTIMIZERS","AdadeltaOptimizer","AdagradOptimizer","AdamOptimizer","AdamaxOptimizer","MomentumOptimizer","RMSPropOptimizer","SGDOptimizer","registerOptimizers","optimizer","registerClass"],"mappings":";;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,MAAMA,IAAa;AAAA,EACfC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AACJ;AACO,SAASC,IAAqB;AACjC,aAAWC,KAAaT;AACpB,IAAAU,EAAcD,CAAS;AAE/B;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/rmsprop_optimizer.js

@@ -0,0 +1,107 @@
+import { ENGINE as S } from "../engine.js";
+import { tidy as d, dispose as M } from "../globals.js";
+import { add as r } from "../ops/add.js";
+import { div as q } from "../ops/div.js";
+import { mul as n } from "../ops/mul.js";
+import { sqrt as N } from "../ops/sqrt.js";
+import { square as f } from "../ops/square.js";
+import { sub as b } from "../ops/sub.js";
+import { zerosLike as g } from "../ops/zeros_like.js";
+import { Optimizer as R } from "./optimizer.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class W extends R {
+  /** @nocollapse */
+  static get className() {
+    return "RMSProp";
+  }
+  constructor(e, t = 0.9, s = 0, a = null, i = !1) {
+    if (super(), this.learningRate = e, this.decay = t, this.momentum = s, this.epsilon = a, this.accumulatedMeanSquares = [], this.accumulatedMoments = [], this.accumulatedMeanGrads = [], this.centered = i, a == null && (this.epsilon = S.backend.epsilon()), e == null)
+      throw new Error("learningRate for RMSPropOptimizer must be defined.");
+  }
+  applyGradients(e) {
+    (Array.isArray(e) ? e.map((s) => s.name) : Object.keys(e)).forEach((s, a) => {
+      const i = S.registeredVariables[s], h = !1;
+      this.accumulatedMeanSquares[a] == null && (this.accumulatedMeanSquares[a] = {
+        originalName: `${s}/rms`,
+        variable: d(() => g(i).variable(h))
+      }), this.accumulatedMoments[a] == null && (this.accumulatedMoments[a] = {
+        originalName: `${s}/momentum`,
+        variable: d(() => g(i).variable(h))
+      }), this.accumulatedMeanGrads[a] == null && this.centered && (this.accumulatedMeanGrads[a] = {
+        originalName: `${s}/mg`,
+        variable: d(() => g(i).variable(h))
+      });
+      const c = Array.isArray(e) ? e[a].tensor : e[s];
+      if (c == null)
+        return;
+      const u = this.accumulatedMeanSquares[a].variable, o = this.accumulatedMoments[a].variable;
+      d(() => {
+        const y = r(n(u, this.decay), n(f(c), 1 - this.decay));
+        if (this.centered) {
+          const m = this.accumulatedMeanGrads[a].variable, l = r(n(m, this.decay), n(c, 1 - this.decay)), p = q(n(c, this.learningRate), N(b(y, r(f(l), this.epsilon)))), v = r(n(o, this.momentum), p);
+          u.assign(y), m.assign(l), o.assign(v);
+          const A = b(i, v);
+          i.assign(A);
+        } else {
+          const m = r(n(u, this.decay), n(f(c), 1 - this.decay)), l = r(n(o, this.momentum), q(n(c, this.learningRate), N(r(m, this.epsilon))));
+          u.assign(m), o.assign(l);
+          const p = b(i, l);
+          i.assign(p);
+        }
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedMeanSquares != null && M(this.accumulatedMeanSquares.map((e) => e.variable)), this.accumulatedMeanGrads != null && this.centered && M(this.accumulatedMeanGrads.map((e) => e.variable)), this.accumulatedMoments != null && M(this.accumulatedMoments.map((e) => e.variable));
+  }
+  async getWeights() {
+    const e = [...this.accumulatedMeanSquares, ...this.accumulatedMoments];
+    return this.centered && e.push(...this.accumulatedMeanGrads), [await this.saveIterations()].concat(e.map((t) => ({ name: t.originalName, tensor: t.variable })));
+  }
+  async setWeights(e) {
+    e = await this.extractIterations(e);
+    const t = this.centered ? e.length / 3 : e.length / 2, s = !1;
+    this.accumulatedMeanSquares = e.slice(0, t).map((a) => ({
+      originalName: a.name,
+      variable: a.tensor.variable(s)
+    })), this.accumulatedMoments = e.slice(t, t * 2).map((a) => ({
+      originalName: a.name,
+      variable: a.tensor.variable(s)
+    })), this.centered && (this.accumulatedMeanGrads = e.slice(t * 2, t * 3).map((a) => ({
+      originalName: a.name,
+      variable: a.tensor.variable(s)
+    })));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      decay: this.decay,
+      momentum: this.momentum,
+      epsilon: this.epsilon,
+      centered: this.centered
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.decay, t.momentum, t.epsilon, t.centered);
+  }
+}
+export {
+  W as RMSPropOptimizer
+};
+//# sourceMappingURL=rmsprop_optimizer.js.map

package/dist/node_modules/@tensorflow/tfjs-core/dist/optimizers/rmsprop_optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rmsprop_optimizer.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-core/dist/optimizers/rmsprop_optimizer.js"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { ENGINE } from '../engine';\nimport { dispose, tidy } from '../globals';\nimport { add } from '../ops/add';\nimport { div } from '../ops/div';\nimport { mul } from '../ops/mul';\nimport { sqrt } from '../ops/sqrt';\nimport { square } from '../ops/square';\nimport { sub } from '../ops/sub';\nimport { zerosLike } from '../ops/zeros_like';\nimport { Optimizer } from './optimizer';\n/** @doclink Optimizer */\nexport class RMSPropOptimizer extends Optimizer {\n    /** @nocollapse */\n    static get className() {\n        // Name matters for Python compatibility.\n        // This is a getter instead of a property because when it's a property, it\n        // prevents the entire class from being tree-shaken.\n        return 'RMSProp';\n    }\n    constructor(learningRate, decay = 0.9, momentum = 0.0, epsilon = null, centered = false) {\n        super();\n        this.learningRate = learningRate;\n        this.decay = decay;\n        this.momentum = momentum;\n        this.epsilon = epsilon;\n        this.accumulatedMeanSquares = [];\n        this.accumulatedMoments = [];\n        this.accumulatedMeanGrads = [];\n        this.centered = centered;\n        if (epsilon == null) {\n            this.epsilon = ENGINE.backend.epsilon();\n        }\n        if (learningRate == null) {\n            throw new Error(`learningRate for RMSPropOptimizer must be defined.`);\n        }\n    }\n    applyGradients(variableGradients) {\n        const variableNames = Array.isArray(variableGradients) ?\n            variableGradients.map(item => item.name) :\n            Object.keys(variableGradients);\n        variableNames.forEach((name, i) => {\n            const value = ENGINE.registeredVariables[name];\n            const trainable = false;\n            if (this.accumulatedMeanSquares[i] == null) {\n                this.accumulatedMeanSquares[i] = {\n                    originalName: `${name}/rms`,\n                    variable: tidy(() => zerosLike(value).variable(trainable))\n                };\n            }\n            if (this.accumulatedMoments[i] == null) {\n                this.accumulatedMoments[i] = {\n                    originalName: `${name}/momentum`,\n                    variable: tidy(() => zerosLike(value).variable(trainable))\n                };\n            }\n            if (this.accumulatedMeanGrads[i] == null && this.centered) {\n                this.accumulatedMeanGrads[i] = {\n                    originalName: `${name}/mg`,\n                    variable: tidy(() => zerosLike(value).variable(trainable))\n                };\n            }\n            const gradient = Array.isArray(variableGradients) ?\n                variableGradients[i].tensor :\n                variableGradients[name];\n            if (gradient == null) {\n                return;\n            }\n            const accumulatedMeanSquare = this.accumulatedMeanSquares[i].variable;\n            const accumulatedMoments = this.accumulatedMoments[i].variable;\n            tidy(() => {\n                const newAccumulatedMeanSquare = add(mul(accumulatedMeanSquare, this.decay), mul(square(gradient), 1 - this.decay));\n                if (this.centered) {\n                    const accumulatedMeanGrad = this.accumulatedMeanGrads[i].variable;\n                    // Centered gradient\n                    const newAccumulatedMeanGrad = add(mul(accumulatedMeanGrad, this.decay), mul(gradient, 1 - this.decay));\n                    const gradContribution = div(mul(gradient, this.learningRate), sqrt(sub(newAccumulatedMeanSquare, add(square(newAccumulatedMeanGrad), this.epsilon))));\n                    const newAccumulatedMoments = add(mul(accumulatedMoments, this.momentum), gradContribution);\n                    accumulatedMeanSquare.assign(newAccumulatedMeanSquare);\n                    accumulatedMeanGrad.assign(newAccumulatedMeanGrad);\n                    accumulatedMoments.assign(newAccumulatedMoments);\n                    const newValue = sub(value, newAccumulatedMoments);\n                    value.assign(newValue);\n                }\n                else {\n                    // Plain gradient\n                    const newAccumulatedMeanSquare = add(mul(accumulatedMeanSquare, this.decay), mul(square(gradient), 1 - this.decay));\n                    const newAccumulatedMoments = add(mul(accumulatedMoments, this.momentum), div(mul(gradient, this.learningRate), sqrt(add(newAccumulatedMeanSquare, this.epsilon))));\n                    accumulatedMeanSquare.assign(newAccumulatedMeanSquare);\n                    accumulatedMoments.assign(newAccumulatedMoments);\n                    const newValue = sub(value, newAccumulatedMoments);\n                    value.assign(newValue);\n                }\n            });\n        });\n        this.incrementIterations();\n    }\n    dispose() {\n        if (this.accumulatedMeanSquares != null) {\n            dispose(this.accumulatedMeanSquares.map(v => v.variable));\n        }\n        if (this.accumulatedMeanGrads != null && this.centered) {\n            dispose(this.accumulatedMeanGrads.map(v => v.variable));\n        }\n        if (this.accumulatedMoments != null) {\n            dispose(this.accumulatedMoments.map(v => v.variable));\n        }\n    }\n    async getWeights() {\n        // Order matters for Python compatibility.\n        const variables = [...this.accumulatedMeanSquares, ...this.accumulatedMoments];\n        if (this.centered) {\n            variables.push(...this.accumulatedMeanGrads);\n        }\n        return [await this.saveIterations()].concat(variables.map(v => ({ name: v.originalName, tensor: v.variable })));\n    }\n    async setWeights(weightValues) {\n        weightValues = await this.extractIterations(weightValues);\n        const variableCount = this.centered ? weightValues.length / 3 : weightValues.length / 2;\n        const trainable = false;\n        this.accumulatedMeanSquares =\n            weightValues.slice(0, variableCount).map(v => ({\n                originalName: v.name,\n                variable: v.tensor.variable(trainable)\n            }));\n        this.accumulatedMoments =\n            weightValues.slice(variableCount, variableCount * 2)\n                .map(v => ({\n                originalName: v.name,\n                variable: v.tensor.variable(trainable)\n            }));\n        if (this.centered) {\n            this.accumulatedMeanGrads =\n                weightValues.slice(variableCount * 2, variableCount * 3)\n                    .map(v => ({\n                    originalName: v.name,\n                    variable: v.tensor.variable(trainable)\n                }));\n        }\n    }\n    getConfig() {\n        return {\n            'learningRate': this.learningRate,\n            'decay': this.decay,\n            'momentum': this.momentum,\n            'epsilon': this.epsilon,\n            'centered': this.centered\n        };\n    }\n    /** @nocollapse */\n    static fromConfig(cls, config) {\n        return new cls(config['learningRate'], config['decay'], config['momentum'], config['epsilon'], config['centered']);\n    }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rmsprop_optimizer.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/optimizers/rmsprop_optimizer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {ENGINE} from '../engine';\nimport {dispose, tidy} from '../globals';\nimport {add} from '../ops/add';\nimport {div} from '../ops/div';\nimport {mul} from '../ops/mul';\nimport {sqrt} from '../ops/sqrt';\nimport {square} from '../ops/square';\nimport {sub} from '../ops/sub';\nimport {zerosLike} from '../ops/zeros_like';\nimport {ConfigDict, Serializable, SerializableConstructor} from '../serialization';\nimport {NamedTensor, NamedTensorMap} from '../tensor_types';\n\nimport {Optimizer, OptimizerVariable} from './optimizer';\n\n/** @doclink Optimizer */\nexport class RMSPropOptimizer extends Optimizer {\n  /** @nocollapse */\n  static get className() {\n    // Name matters for Python compatibility.\n    // This is a getter instead of a property because when it's a property, it\n    // prevents the entire class from being tree-shaken.\n    return 'RMSProp';\n  }\n  private centered: boolean;\n\n  private accumulatedMeanSquares: OptimizerVariable[] = [];\n  private accumulatedMoments: OptimizerVariable[] = [];\n  private accumulatedMeanGrads: OptimizerVariable[] = [];\n\n  constructor(\n      protected learningRate: number, protected decay = 0.9,\n      protected momentum = 0.0, protected epsilon: number = null,\n      centered = false) {\n    super();\n\n    this.centered = centered;\n\n    if (epsilon == null) {\n      this.epsilon = ENGINE.backend.epsilon();\n    }\n    if (learningRate == null) {\n      throw new Error(`learningRate for RMSPropOptimizer must be defined.`);\n    }\n  }\n\n  applyGradients(variableGradients: NamedTensorMap|NamedTensor[]) {\n    const variableNames = Array.isArray(variableGradients) ?\n        variableGradients.map(item => item.name) :\n        Object.keys(variableGradients);\n\n    variableNames.forEach((name, i) => {\n      const value = ENGINE.registeredVariables[name];\n      const trainable = false;\n      if (this.accumulatedMeanSquares[i] == null) {\n        this.accumulatedMeanSquares[i] = {\n          originalName: `${name}/rms`,\n          variable: tidy(() => zerosLike(value).variable(trainable))\n        };\n      }\n      if (this.accumulatedMoments[i] == null) {\n        this.accumulatedMoments[i] = {\n          originalName: `${name}/momentum`,\n          variable: tidy(() => zerosLike(value).variable(trainable))\n        };\n      }\n      if (this.accumulatedMeanGrads[i] == null && this.centered) {\n        this.accumulatedMeanGrads[i] = {\n          originalName: `${name}/mg`,\n          variable: tidy(() => zerosLike(value).variable(trainable))\n        };\n      }\n\n      const gradient = Array.isArray(variableGradients) ?\n          variableGradients[i].tensor :\n          variableGradients[name];\n      if (gradient == null) {\n        return;\n      }\n\n      const accumulatedMeanSquare = this.accumulatedMeanSquares[i].variable;\n      const accumulatedMoments = this.accumulatedMoments[i].variable;\n      tidy(() => {\n        const newAccumulatedMeanSquare =\n            add(mul(accumulatedMeanSquare, this.decay),\n                mul(square(gradient), 1 - this.decay));\n\n        if (this.centered) {\n          const accumulatedMeanGrad = this.accumulatedMeanGrads[i].variable;\n          // Centered gradient\n          const newAccumulatedMeanGrad =\n              add(mul(accumulatedMeanGrad, this.decay),\n                  mul(gradient, 1 - this.decay));\n\n          const gradContribution =\n              div(mul(gradient, this.learningRate),\n                  sqrt(\n                      sub(newAccumulatedMeanSquare,\n                          add(square(newAccumulatedMeanGrad), this.epsilon))));\n          const newAccumulatedMoments =\n              add(mul(accumulatedMoments, this.momentum), gradContribution);\n\n          accumulatedMeanSquare.assign(newAccumulatedMeanSquare);\n          accumulatedMeanGrad.assign(newAccumulatedMeanGrad);\n          accumulatedMoments.assign(newAccumulatedMoments);\n\n          const newValue = sub(value, newAccumulatedMoments);\n          value.assign(newValue);\n        } else {\n          // Plain gradient\n          const newAccumulatedMeanSquare =\n              add(mul(accumulatedMeanSquare, this.decay),\n                  mul(square(gradient), 1 - this.decay));\n\n          const newAccumulatedMoments =\n              add(mul(accumulatedMoments, this.momentum),\n                  div(mul(gradient, this.learningRate),\n                      sqrt(add(newAccumulatedMeanSquare, this.epsilon))));\n\n          accumulatedMeanSquare.assign(newAccumulatedMeanSquare);\n          accumulatedMoments.assign(newAccumulatedMoments);\n\n          const newValue = sub(value, newAccumulatedMoments);\n          value.assign(newValue);\n        }\n      });\n    });\n    this.incrementIterations();\n  }\n\n  override dispose(): void {\n    if (this.accumulatedMeanSquares != null) {\n      dispose(this.accumulatedMeanSquares.map(v => v.variable));\n    }\n    if (this.accumulatedMeanGrads != null && this.centered) {\n      dispose(this.accumulatedMeanGrads.map(v => v.variable));\n    }\n    if (this.accumulatedMoments != null) {\n      dispose(this.accumulatedMoments.map(v => v.variable));\n    }\n  }\n\n  override async getWeights(): Promise<NamedTensor[]> {\n    // Order matters for Python compatibility.\n    const variables: OptimizerVariable[] =\n        [...this.accumulatedMeanSquares, ...this.accumulatedMoments];\n    if (this.centered) {\n      variables.push(...this.accumulatedMeanGrads);\n    }\n    return [await this.saveIterations()].concat(\n        variables.map(v => ({name: v.originalName, tensor: v.variable})));\n  }\n\n  override async setWeights(weightValues: NamedTensor[]): Promise<void> {\n    weightValues = await this.extractIterations(weightValues);\n    const variableCount =\n        this.centered ? weightValues.length / 3 : weightValues.length / 2;\n    const trainable = false;\n    this.accumulatedMeanSquares =\n        weightValues.slice(0, variableCount).map(v => ({\n                                                   originalName: v.name,\n                                                   variable: v.tensor.variable(\n                                                       trainable)\n                                                 }));\n    this.accumulatedMoments =\n        weightValues.slice(variableCount, variableCount * 2)\n            .map(v => ({\n                   originalName: v.name,\n                   variable: v.tensor.variable(trainable)\n                 }));\n    if (this.centered) {\n      this.accumulatedMeanGrads =\n          weightValues.slice(variableCount * 2, variableCount * 3)\n              .map(v => ({\n                     originalName: v.name,\n                     variable: v.tensor.variable(trainable)\n                   }));\n    }\n  }\n\n  getConfig(): ConfigDict {\n    return {\n      'learningRate': this.learningRate,\n      'decay': this.decay,\n      'momentum': this.momentum,\n      'epsilon': this.epsilon,\n      'centered': this.centered\n    };\n  }\n\n  /** @nocollapse */\n  static override fromConfig<T extends Serializable>(\n      cls: SerializableConstructor<T>, config: ConfigDict): T {\n    return new cls(\n        config['learningRate'], config['decay'], config['momentum'],\n        config['epsilon'], config['centered']);\n  }\n}\n"]}"],"names":["RMSPropOptimizer","Optimizer","learningRate","decay","momentum","epsilon","centered","ENGINE","variableGradients","item","name","i","value","trainable","tidy","zerosLike","gradient","accumulatedMeanSquare","accumulatedMoments","newAccumulatedMeanSquare","add","mul","square","accumulatedMeanGrad","newAccumulatedMeanGrad","gradContribution","div","sqrt","sub","newAccumulatedMoments","newValue","dispose","v","variables","weightValues","variableCount","cls","config"],"mappings":"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","x_google_ignoreList":[0]}