save

Author: dsmilkov

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensorflow/tfjs-core",
-  "version": "1.0.0-alpha3",
+  "version": "1.0.0-alpha4",
   "description": "Hardware-accelerated JavaScript library for machine intelligence",
   "private": false,
   "main": "dist/index.js",
@@ -23,11 +23,11 @@
     "clang-format": "~1.2.4",
     "jasmine": "~3.1.0",
     "jasmine-core": "~3.1.0",
-    "karma": "~2.0.2",
-    "karma-browserstack-launcher": "~1.3.0",
+    "karma": "~4.0.0",
+    "karma-browserstack-launcher": "~1.4.0",
     "karma-chrome-launcher": "~2.2.0",
     "karma-jasmine": "~1.1.0",
-    "karma-typescript": "~3.0.12",
+    "karma-typescript": "~4.0.0",
     "npm-run-all": "~4.1.3",
     "rimraf": "~2.6.2",
     "rollup": "~0.58.2",

src/engine.ts

@@ -478,7 +478,8 @@ export class Engine implements TensorManager, TensorTracker, DataMover {
   gradients<T extends Tensor>(
       f: () => T, xs: Tensor[], dy?: T,
       allowNoGradients = false): {value: T, grads: Tensor[]} {
-    util.assert(xs.length > 0, 'gradients() received an empty list of xs.');
+    util.assert(
+        xs.length > 0, () => 'gradients() received an empty list of xs.');
     if (dy != null && dy.dtype !== 'float32') {
       throw new Error(`dy must have 'float32' dtype, but has '${dy.dtype}'`);
     }
@@ -487,7 +488,7 @@ export class Engine implements TensorManager, TensorTracker, DataMover {
       const y = f();
       util.assert(
           y instanceof Tensor,
-          'The result y returned by f() must be a tensor.');
+          () => 'The result y returned by f() must be a tensor.');
       // Filter out the nodes that don't connect x => y.
       const filteredTape = getFilteredNodesXToY(this.activeTape, xs, y);
       if (!allowNoGradients && filteredTape.length === 0 && xs.length > 0) {
@@ -512,11 +513,12 @@ export class Engine implements TensorManager, TensorTracker, DataMover {
       (...args: Tensor[]) => T {
     util.assert(
         util.isFunction(f),
-        'The f passed in customGrad(f) must be a function.');
+        () => 'The f passed in customGrad(f) must be a function.');
     return (...inputs: Tensor[]): T => {
       util.assert(
           inputs.every(t => t instanceof Tensor),
-          'The args passed in customGrad(f)(x1, x2,...) must all be tensors');
+          () => 'The args passed in customGrad(f)(x1, x2,...) must all be ' +
+              'tensors');
 
       let gradientsFunc: (dy: T) => Tensor | Tensor[];
       let result: T;
@@ -528,11 +530,13 @@ export class Engine implements TensorManager, TensorTracker, DataMover {
               const {value, gradFunc} = f(...inputs);
               util.assert(
                   value instanceof Tensor,
-                  'The function f passed in customGrad(f) must return an ' +
+                  () =>
+                      'The function f passed in customGrad(f) must return an ' +
                       'object where `obj.value` is a tensor');
               util.assert(
                   util.isFunction(gradFunc),
-                  'The function f passed in customGrad(f) must return an ' +
+                  () =>
+                      'The function f passed in customGrad(f) must return an ' +
                       'object where `obj.gradFunc` is a function.');
               gradientsFunc = gradFunc;
               return value;
@@ -545,14 +549,14 @@ export class Engine implements TensorManager, TensorTracker, DataMover {
           const grads: Tensor[] = Array.isArray(res) ? res : [res];
           util.assert(
               grads.length === inputs.length,
-              'The function f passed in customGrad(f) must return an object ' +
-                  'where `obj.gradFunc` is a function that returns the same ' +
-                  'number of tensors as inputs passed to f(...).');
+              () => 'The function f passed in customGrad(f) must return an ' +
+                  'object where `obj.gradFunc` is a function that returns ' +
+                  'the same number of tensors as inputs passed to f(...).');
           util.assert(
               grads.every(t => t instanceof Tensor),
-              'The function f passed in customGrad(f) must return an object ' +
-                  'where `obj.gradFunc` is a function that returns a list of ' +
-                  'only tensors.');
+              () => 'The function f passed in customGrad(f) must return an ' +
+                  'object where `obj.gradFunc` is a function that returns a ' +
+                  'list of only tensors.');
           return grads;
         };
         this.addTapeNode(inputs, result, gradFunc);

src/environment.ts

@@ -322,6 +322,8 @@ export class Environment {
       return this.get('WEBGL_PACK');
     } else if (feature === 'WEBGL_PACK_IMAGE_OPERATIONS') {
       return this.get('WEBGL_PACK');
+    } else if (feature === 'WEBGL_PACK_REDUCE') {
+      return this.get('WEBGL_PACK');
     } else if (feature === 'WEBGL_LAZILY_UNPACK') {
       return this.get('WEBGL_PACK');
     } else if (feature === 'WEBGL_CONV_IM2COL') {

src/environment_util.ts

@@ -42,6 +42,8 @@ export interface Features {
   'WEBGL_PACK_ARRAY_OPERATIONS'?: boolean;
   // Whether we will pack image operations.
   'WEBGL_PACK_IMAGE_OPERATIONS'?: boolean;
+  // Whether we will pack reduction ops.
+  'WEBGL_PACK_REDUCE'?: boolean;
   // Whether we will use the im2col algorithm to speed up convolutions.
   'WEBGL_CONV_IM2COL'?: boolean;
   // The maximum texture dimension.
@@ -116,6 +118,7 @@ export const URL_PROPERTIES: URLProperty[] = [
   {name: 'WEBGL_PACK_BINARY_OPERATIONS', type: Type.BOOLEAN},
   {name: 'WEBGL_PACK_ARRAY_OPERATIONS', type: Type.BOOLEAN},
   {name: 'WEBGL_PACK_IMAGE_OPERATIONS', type: Type.BOOLEAN},
+  {name: 'WEBGL_PACK_REDUCE', type: Type.BOOLEAN},
   {name: 'WEBGL_CONV_IM2COL', type: Type.BOOLEAN},
   {name: 'WEBGL_MAX_TEXTURE_SIZE', type: Type.NUMBER},
   {name: 'WEBGL_NUM_MB_BEFORE_PAGING', type: Type.NUMBER},

src/gradients.ts

@@ -72,13 +72,15 @@ function gradScope<T extends TensorContainer>(
 /** @doc {heading: 'Training', subheading: 'Gradients'} */
 function grad<I extends Tensor, O extends Tensor>(f: (x: I) => O): (
     x: I, dy?: O) => I {
-  util.assert(util.isFunction(f), 'The f passed in grad(f) must be a function');
+  util.assert(
+      util.isFunction(f), () => 'The f passed in grad(f) must be a function');
   return (x: I, dy?: O): I => {
     util.assert(
-        x instanceof Tensor, 'The x passed in grad(f)(x) must be a tensor');
+        x instanceof Tensor,
+        () => 'The x passed in grad(f)(x) must be a tensor');
     util.assert(
         dy == null || dy instanceof Tensor,
-        'The dy passed in grad(f)(x, dy) must be a tensor');
+        () => 'The dy passed in grad(f)(x, dy) must be a tensor');
     return ENV.engine.tidy(() => {
       const {value, grads} = ENV.engine.gradients(() => f(x), [x], dy);
       if (dy != null) {
@@ -124,14 +126,14 @@ function grad<I extends Tensor, O extends Tensor>(f: (x: I) => O): (
 function grads<O extends Tensor>(f: (...args: Tensor[]) => O): (
     args: Tensor[], dy?: O) => Tensor[] {
   util.assert(
-      util.isFunction(f), 'The f passed in grads(f) must be a function');
+      util.isFunction(f), () => 'The f passed in grads(f) must be a function');
   return (args: Tensor[], dy?: O): Tensor[] => {
     util.assert(
         Array.isArray(args) && args.every(arg => arg instanceof Tensor),
-        'The args passed in grads(f)(args) must be an array of tensors');
+        () => 'The args passed in grads(f)(args) must be an array of tensors');
     util.assert(
         dy == null || dy instanceof Tensor,
-        'The dy passed in grads(f)(args, dy) must be a tensor');
+        () => 'The dy passed in grads(f)(args, dy) must be a tensor');
     return ENV.engine.tidy(() => {
       const {value, grads} = ENV.engine.gradients(() => f(...args), args, dy);
       if (dy != null) {
@@ -176,14 +178,15 @@ function valueAndGrad<I extends Tensor, O extends Tensor>(f: (x: I) => O): (
   grad: I;
 } {
   util.assert(
-      util.isFunction(f), 'The f passed in valueAndGrad(f) must be a function');
+      util.isFunction(f),
+      () => 'The f passed in valueAndGrad(f) must be a function');
   return (x: I, dy?: O) => {
     util.assert(
         x instanceof Tensor,
-        'The x passed in valueAndGrad(f)(x) must be a tensor');
+        () => 'The x passed in valueAndGrad(f)(x) must be a tensor');
     util.assert(
         dy == null || dy instanceof Tensor,
-        'The dy passed in valueAndGrad(f)(x, dy) must be a tensor');
+        () => 'The dy passed in valueAndGrad(f)(x, dy) must be a tensor');
     const {grads, value} = ENV.engine.gradients(() => f(x), [x], dy);
     checkGrads(grads);
     return {grad: grads[0] as I, value: value as O};
@@ -227,14 +230,15 @@ function valueAndGrads<O extends Tensor>(f: (...args: Tensor[]) => O): (
 } {
   util.assert(
       util.isFunction(f),
-      'The f passed in valueAndGrads(f) must be a function');
+      () => 'The f passed in valueAndGrads(f) must be a function');
   return (args: Tensor[], dy?: O) => {
     util.assert(
         Array.isArray(args) && args.every(arg => arg instanceof Tensor),
-        'The args passed in valueAndGrads(f)(args) must be array of tensors');
+        () => 'The args passed in valueAndGrads(f)(args) must be array of ' +
+            'tensors');
     util.assert(
         dy == null || dy instanceof Tensor,
-        'The dy passed in valueAndGrads(f)(args, dy) must be a tensor');
+        () => 'The dy passed in valueAndGrads(f)(args, dy) must be a tensor');
     const res = ENV.engine.gradients(() => f(...args), args, dy);
     if (dy != null) {
       util.assertShapesMatch(
@@ -273,11 +277,12 @@ function variableGrads(f: () => Scalar, varList?: Variable[]):
     {value: Scalar, grads: NamedTensorMap} {
   util.assert(
       util.isFunction(f),
-      'The f passed in variableGrads(f) must be a function');
+      () => 'The f passed in variableGrads(f) must be a function');
   util.assert(
       varList == null ||
           Array.isArray(varList) && varList.every(v => v instanceof Variable),
-      'The varList passed in variableGrads(f, varList) must be an array ' +
+      () =>
+          'The varList passed in variableGrads(f, varList) must be an array ' +
           'of variables');
   if (varList == null) {
     // Get all of the trainable variables.
@@ -291,7 +296,8 @@ function variableGrads(f: () => Scalar, varList?: Variable[]):
   varList = varList.filter(variable => variable.trainable);
   util.assert(
       varList.length > 0,
-      `variableGrads() expects at least one of the input variables to be ` +
+      () =>
+          `variableGrads() expects at least one of the input variables to be ` +
           `trainable, but none of the ${originalVarCount} variables is ` +
           `trainable.`);
 
@@ -301,12 +307,12 @@ function variableGrads(f: () => Scalar, varList?: Variable[]):
 
   util.assert(
       grads.some(g => g != null),
-      'Cannot find a connection between any variable and the result of the ' +
-          'loss function y=f(x). Please make sure the operations that use ' +
-          'variables are inside the function f passed to minimize().');
+      () => 'Cannot find a connection between any variable and the result of ' +
+          'the loss function y=f(x). Please make sure the operations that ' +
+          'use variables are inside the function f passed to minimize().');
   util.assert(
       value.rank === 0,
-      `The f passed in variableGrads(f) must return a scalar, but it ` +
+      () => `The f passed in variableGrads(f) must return a scalar, but it ` +
           `returned a rank-${value.rank} tensor`);
 
   const namedGrads: NamedTensorMap = {};

src/io/browser_http.ts

@@ -25,7 +25,7 @@ import {assert} from '../util';
 
 import {concatenateArrayBuffers, getModelArtifactsInfoForJSON} from './io_utils';
 import {IORouter, IORouterRegistry} from './router_registry';
-import {IOHandler, ModelArtifacts, SaveResult, WeightsManifestConfig, WeightsManifestEntry} from './types';
+import {IOHandler, LoadOptions, ModelArtifacts, OnProgressCallback, SaveResult, WeightsManifestConfig, WeightsManifestEntry} from './types';
 import {loadWeightsAsArrayBuffer} from './weights_loader';
 
 const OCTET_STREAM_MIME_TYPE = 'application/octet-stream';
@@ -41,52 +41,61 @@ export class BrowserHTTPRequest implements IOHandler {
 
   static readonly URL_SCHEME_REGEX = /^https?:\/\//;
 
-  constructor(
-      path: string|string[], requestInit?: RequestInit,
-      private readonly weightPathPrefix?: string, fetchFunc?: Function,
-      private readonly onProgress?: Function) {
-    if (fetchFunc == null) {
+  private readonly weightPathPrefix: string;
+  private readonly onProgress: OnProgressCallback;
+
+  constructor(path: string|string[], loadOptions?: LoadOptions) {
+    if (loadOptions == null) {
+      loadOptions = {};
+    }
+    this.weightPathPrefix = loadOptions.weightPathPrefix;
+    this.onProgress = loadOptions.onProgress;
+
+    if (loadOptions.fetchFunc == null) {
       if (typeof fetch === 'undefined') {
         throw new Error(
             'browserHTTPRequest is not supported outside the web browser ' +
             'without a fetch polyfill.');
       }
       // Make sure fetch is always bound to window (the
       // original object) when available.
-      fetchFunc = fetch.bind(typeof window === 'undefined' ? null : window);
+      loadOptions.fetchFunc =
+          fetch.bind(typeof window === 'undefined' ? null : window);
     } else {
       assert(
-          typeof fetchFunc === 'function',
-          'Must pass a function that matches the signature of ' +
+          typeof loadOptions.fetchFunc === 'function',
+          () => 'Must pass a function that matches the signature of ' +
               '`fetch` (see ' +
               'https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)');
     }
 
     this.fetchFunc = (path: string, requestInits: RequestInit) => {
       // tslint:disable-next-line:no-any
-      return fetchFunc(path, requestInits).catch((error: any) => {
+      return loadOptions.fetchFunc(path, requestInits).catch((error: any) => {
         throw new Error(`Request for ${path} failed due to error: ${error}`);
       });
     };
 
     assert(
         path != null && path.length > 0,
-        'URL path for browserHTTPRequest must not be null, undefined or ' +
+        () =>
+            'URL path for browserHTTPRequest must not be null, undefined or ' +
             'empty.');
 
     if (Array.isArray(path)) {
       assert(
           path.length === 2,
-          'URL paths for browserHTTPRequest must have a length of 2, ' +
+          () => 'URL paths for browserHTTPRequest must have a length of 2, ' +
               `(actual length is ${path.length}).`);
     }
     this.path = path;
 
-    if (requestInit != null && requestInit.body != null) {
+    if (loadOptions.requestInit != null &&
+        loadOptions.requestInit.body != null) {
       throw new Error(
           'requestInit is expected to have no pre-existing body, but has one.');
     }
-    this.requestInit = requestInit || {};
+    this.requestInit = loadOptions.requestInit || {};
   }
 
   async save(modelArtifacts: ModelArtifacts): Promise<SaveResult> {
@@ -235,8 +244,11 @@ export class BrowserHTTPRequest implements IOHandler {
         fetchURLs.push(pathPrefix + path + suffix);
       });
     });
-    const buffers = await loadWeightsAsArrayBuffer(
-        fetchURLs, this.requestInit, this.getFetchFunc(), this.onProgress);
+    const buffers = await loadWeightsAsArrayBuffer(fetchURLs, {
+      requestInit: this.requestInit,
+      fetchFunc: this.getFetchFunc(),
+      onProgress: this.onProgress
+    });
     return [weightSpecs, concatenateArrayBuffers(buffers)];
   }
 
@@ -277,7 +289,7 @@ export function isHTTPScheme(url: string): boolean {
 }
 
 export const httpRequestRouter: IORouter =
-    (url: string|string[], onProgress?: Function) => {
+    (url: string|string[], onProgress?: OnProgressCallback) => {
       if (typeof fetch === 'undefined') {
         // browserHTTPRequest uses `fetch`, if one wants to use it in node.js
         // they have to setup a global fetch polyfill.
@@ -290,7 +302,7 @@ export const httpRequestRouter: IORouter =
           isHTTP = isHTTPScheme(url);
         }
         if (isHTTP) {
-          return browserHTTPRequest(url, null, null, null, onProgress);
+          return browserHTTPRequest(url, {onProgress});
         }
       }
       return null;
@@ -433,17 +445,17 @@ IORouterRegistry.registerLoadRouter(httpRequestRouter);
  * topology (filename: 'model.json') and the weights of the model (filename:
  * 'model.weights.bin') will be appended to the body. If `requestInit` has a
  * `body`, an Error will be thrown.
- * @param weightPathPrefix Optional, this specifies the path prefix for weight
- *   files, by default this is calculated from the path param.
- * @param fetchFunc Optional, custom `fetch` function. E.g., in Node.js,
- *   the `fetch` from node-fetch can be used here.
- * @param onProgress Optional, progress callback function, fired periodically
- *   before the load is completed.
+ * @param loadOptions Optional configuration for the loading. It includes the
+ *   following fields:
+ *   - weightPathPrefix Optional, this specifies the path prefix for weight
+ *     files, by default this is calculated from the path param.
+ *   - fetchFunc Optional, custom `fetch` function. E.g., in Node.js,
+ *     the `fetch` from node-fetch can be used here.
+ *   - onProgress Optional, progress callback function, fired periodically
+ *     before the load is completed.
  * @returns An instance of `IOHandler`.
  */
 export function browserHTTPRequest(
-    path: string|string[], requestInit?: RequestInit, weightPathPrefix?: string,
-    fetchFunc?: Function, onProgress?: Function): IOHandler {
-  return new BrowserHTTPRequest(
-      path, requestInit, weightPathPrefix, fetchFunc, onProgress);
+    path: string|string[], loadOptions?: LoadOptions): IOHandler {
+  return new BrowserHTTPRequest(path, loadOptions);
 }